griptape-nodes 0.51.2__py3-none-any.whl → 0.52.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/library_manager.py

@@ -95,6 +95,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.uv_utils import find_uv_bin
 from griptape_nodes.utils.version_utils import get_complete_version_string
 
@@ -662,7 +663,7 @@ class LibraryManager:
         result = ListCategoriesInLibraryResultSuccess(categories=categories)
         return result
 
-    def register_library_from_file_request(self, request: RegisterLibraryFromFileRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915 (complex logic needs branches)
+    async def register_library_from_file_request(self, request: RegisterLibraryFromFileRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915 (complex logic needs branches)
         file_path = request.file_path
 
         # Convert to Path object if it's a string
@@ -781,7 +782,7 @@ class LibraryManager:
 
                 # Only install dependencies if conditions are met
                 try:
-                    library_venv_python_path = self._init_library_venv(venv_path)
+                    library_venv_python_path = await self._init_library_venv(venv_path)
                 except RuntimeError as e:
                     self._library_file_path_to_info[file_path] = LibraryManager.LibraryInfo(
                         library_path=file_path,
@@ -816,7 +817,7 @@ class LibraryManager:
                     logger.info(
                         "Installing dependencies for library '%s' with pip in venv at %s", library_data.name, venv_path
                     )
-                    subprocess.run(  # noqa: S603
+                    await subprocess_run(
                         [
                             sys.executable,
                             "-m",
@@ -920,7 +921,7 @@ class LibraryManager:
                 logger.error(details)
                 return RegisterLibraryFromFileResultFailure(result_details=details)
 
-    def register_library_from_requirement_specifier_request(
+    async def register_library_from_requirement_specifier_request(
         self, request: RegisterLibraryFromRequirementSpecifierRequest
     ) -> ResultPayload:
         try:
@@ -930,7 +931,7 @@ class LibraryManager:
 
             # Only install dependencies if conditions are met
             try:
-                library_python_venv_path = self._init_library_venv(venv_path)
+                library_python_venv_path = await self._init_library_venv(venv_path)
             except RuntimeError as e:
                 details = f"Attempted to install library '{request.requirement_specifier}'. Failed when creating the virtual environment: {e}"
                 logger.error(details)
@@ -948,14 +949,14 @@ class LibraryManager:
                 uv_path = find_uv_bin()
 
                 logger.info("Installing dependency '%s' with pip in venv at %s", package_name, venv_path)
-                subprocess.run(  # noqa: S603
+                await subprocess_run(
                     [
                         uv_path,
                         "pip",
                         "install",
                         request.requirement_specifier,
                         "--python",
-                        library_python_venv_path,
+                        str(library_python_venv_path),
                     ],
                     check=True,
                     capture_output=True,
@@ -986,7 +987,7 @@ class LibraryManager:
 
         return RegisterLibraryFromRequirementSpecifierResultSuccess(library_name=request.requirement_specifier)
 
-    def _init_library_venv(self, library_venv_path: Path) -> Path:
+    async def _init_library_venv(self, library_venv_path: Path) -> Path:
         """Initialize a virtual environment for the library.
 
         If the virtual environment already exists, it will not be recreated.
@@ -1022,7 +1023,7 @@ class LibraryManager:
             try:
                 uv_path = find_uv_bin()
                 logger.info("Creating virtual environment at %s with Python %s", library_venv_path, python_version)
-                subprocess.run(  # noqa: S603
+                await subprocess_run(
                     [uv_path, "venv", str(library_venv_path), "--python", python_version],
                     check=True,
                     capture_output=True,
@@ -1491,7 +1492,7 @@ class LibraryManager:
 
         return node_class
 
-    def load_all_libraries_from_config(self) -> None:
+    async def load_all_libraries_from_config(self) -> None:
         # Comment out lines 1503-1545 and call the _load libraries from provenance system to test the other functionality.
 
         # Load metadata for all libraries to determine which ones can be safely loaded
@@ -1527,7 +1528,7 @@ class LibraryManager:
                 register_request = RegisterLibraryFromFileRequest(
                     file_path=library_result.file_path, load_as_default_library=False
                 )
-                register_result = self.register_library_from_file_request(register_request)
+                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
@@ -1540,12 +1541,12 @@ class LibraryManager:
         user_libraries_section = "app_events.on_app_initialization_complete.libraries_to_register"
         self._remove_missing_libraries_from_config(config_category=user_libraries_section)
 
-    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
+    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!
-        self.load_all_libraries_from_config()
+        await self.load_all_libraries_from_config()
 
         # We have to load all libraries before we attempt to load workflows.
 
@@ -1603,7 +1604,7 @@ class LibraryManager:
         )
         console.print(message)
 
-    def _load_libraries_from_provenance_system(self) -> None:
+    async def _load_libraries_from_provenance_system(self) -> None:
         """Load libraries using the new provenance-based system with FSM.
 
         This method converts libraries_to_register entries into LibraryProvenanceLocalFile
@@ -1632,7 +1633,7 @@ class LibraryManager:
 
             # Add to directory as user candidate (defaults to active=True)
             # This automatically creates FSM and runs evaluation
-            self._library_directory.add_user_candidate(provenance)
+            await self._library_directory.add_user_candidate(provenance)
 
             logger.debug("Added library provenance: %s", provenance.get_display_name())
 
@@ -1661,8 +1662,8 @@ class LibraryManager:
 
         # Process installable candidates through installation and loading
         for candidate in installable_candidates:
-            if self._library_directory.install_library(candidate.provenance):
-                self._library_directory.load_library(candidate.provenance)
+            if await self._library_directory.install_library(candidate.provenance):
+                await self._library_directory.load_library(candidate.provenance)
 
     def _report_library_name_conflicts(self) -> None:
         """Report on library name conflicts found during evaluation."""
@@ -1997,7 +1998,7 @@ class LibraryManager:
             ]
             config_mgr.set_config_value(config_category, libraries_to_register_category)
 
-    def reload_all_libraries_request(self, request: ReloadAllLibrariesRequest) -> ResultPayload:  # noqa: ARG002
+    async def reload_all_libraries_request(self, request: ReloadAllLibrariesRequest) -> ResultPayload:  # noqa: ARG002
         # Start with a clean slate.
         clear_all_request = ClearAllObjectStateRequest(i_know_what_im_doing=True)
         clear_all_result = GriptapeNodes.handle_request(clear_all_request)
@@ -2023,7 +2024,7 @@ class LibraryManager:
                 return ReloadAllLibrariesResultFailure(result_details=details)
 
         # Load (or reload, which should trigger a hot reload) all libraries
-        self.load_all_libraries_from_config()
+        await self.load_all_libraries_from_config()
 
         details = (
             "Successfully reloaded all libraries. All object state was cleared and previous libraries were unloaded."

griptape_nodes/retained_mode/managers/node_manager.py

@@ -75,6 +75,9 @@ from griptape_nodes.retained_mode.events.node_events import (
     GetAllNodeInfoRequest,
     GetAllNodeInfoResultFailure,
     GetAllNodeInfoResultSuccess,
+    GetFlowForNodeRequest,
+    GetFlowForNodeResultFailure,
+    GetFlowForNodeResultSuccess,
     GetNodeMetadataRequest,
     GetNodeMetadataResultFailure,
     GetNodeMetadataResultSuccess,
@@ -199,6 +202,7 @@ class NodeManager:
         )
         event_manager.assign_manager_to_request_type(DuplicateSelectedNodesRequest, self.on_duplicate_selected_nodes)
         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)
 
     def handle_node_rename(self, old_name: str, new_name: str) -> None:
         # Get the node itself
@@ -705,7 +709,7 @@ class NodeManager:
             else:
                 failed_nodes[actual_node_name] = result.result_details
 
-        if not updated_nodes:
+        if failed_nodes:
             return BatchSetNodeMetadataResultFailure(
                 result_details=f"Failed to update any nodes. Failed nodes: {failed_nodes}"
             )
@@ -961,6 +965,7 @@ class NodeManager:
             allowed_modes=allowed_modes,
             ui_options=request.ui_options,
             parent_container_name=request.parent_container_name,
+            settable=request.settable,
         )
         try:
             if request.parent_container_name and request.initial_setup:
@@ -968,7 +973,6 @@ class NodeManager:
                 if parameter_parent is not None:
                     parameter_parent.add_child(new_param)
             else:
-                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 '{node_name}'. Error: {e}"
@@ -1168,6 +1172,7 @@ class NodeManager:
             mode_allowed_property=allows_property,
             mode_allowed_output=allows_output,
             is_user_defined=getattr(element, "user_defined", False),
+            settable=getattr(element, "settable", None),
             ui_options=getattr(element, "ui_options", None),
         )
         return result
@@ -1257,7 +1262,7 @@ class NodeManager:
         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:
+    def modify_key_parameter_fields(self, request: AlterParameterDetailsRequest, parameter: Parameter) -> None:  # noqa: C901, PLR0912
         if request.type is not None:
             parameter.type = request.type
         if request.input_types is not None:
@@ -1282,6 +1287,8 @@ class NodeManager:
                 parameter.allowed_modes.add(ParameterMode.OUTPUT)
             else:
                 parameter.allowed_modes.discard(ParameterMode.OUTPUT)
+        if request.settable is not None:
+            parameter.settable = request.settable
 
     def _validate_and_break_invalid_connections(
         self, node_name: str, parameter: Parameter, request: AlterParameterDetailsRequest
@@ -1549,7 +1556,50 @@ class NodeManager:
             result = SetParameterValueResultFailure(result_details=details)
             return result
 
+        # Validate incoming connection source fields consistency
+        incoming_node_set = request.incoming_connection_source_node_name is not None
+        incoming_param_set = request.incoming_connection_source_parameter_name is not None
+        if incoming_node_set != incoming_param_set:
+            details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because incoming connection source fields must both be None or both be set. Got incoming_connection_source_node_name={request.incoming_connection_source_node_name}, incoming_connection_source_parameter_name={request.incoming_connection_source_parameter_name}."
+            logger.error(details)
+            result = SetParameterValueResultFailure(result_details=details)
+            return result
+
+        # Prevent manual property setting on parameters that have both INPUT and PROPERTY modes when they have incoming connections
+        # When a parameter can accept both input connections AND manual property values, having an active connection should
+        # make the parameter non-settable as a property to avoid conflicts between connected values and manual values
+        # Skip this check if: initial_setup (workflow loading), or incoming_connection_source fields are set (system passing upstream values)
+        if (
+            not request.initial_setup
+            and not incoming_node_set  # If incoming connection source fields are set, this is a legitimate upstream value pass
+            and ParameterMode.INPUT in parameter.allowed_modes
+            and ParameterMode.PROPERTY in parameter.allowed_modes
+        ):
+            # Check if this parameter has any incoming connections
+            connections = GriptapeNodes.FlowManager().get_connections()
+            target_connections = connections.incoming_index.get(node_name)
+            if target_connections is not None:
+                param_connections = target_connections.get(request.parameter_name)
+                if param_connections:  # Has incoming connections
+                    # TODO: https://github.com/griptape-ai/griptape-nodes/issues/1965 Consider emitting UI events when parameters become settable/unsettable due to connection changes
+                    details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because this parameter has incoming connections and cannot be set as a property while connected."
+                    logger.error(details)
+                    result = SetParameterValueResultFailure(result_details=details)
+                    return result
+
+        # Call before_value_set hook (allows nodes to modify values and temporarily control settable state)
+        try:
+            modified_value = node.before_value_set(parameter, request.value)
+            if modified_value is not None:
+                request.value = modified_value
+        except Exception as err:
+            details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because before_value_set hook raised exception: {err}"
+            logger.error(details)
+            result = SetParameterValueResultFailure(result_details=details)
+            return result
+
         # Validate that parameters can be set at all (note: we want the value to be set during initial setup, but not after)
+        # This check comes after before_value_set to allow nodes to temporarily modify settable state
         if not parameter.settable and not request.initial_setup:
             details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because that Parameter was flagged as not settable."
             logger.error(details)
@@ -1596,8 +1646,9 @@ class NodeManager:
             # Mark node as unresolved, broadcast an event
             node.make_node_unresolved(current_states_to_trigger_change_event=set({NodeResolutionState.RESOLVED}))
             # Get the flow
-            # Pass the value through!
-            # Optional data_type parameter for internal handling!
+            # Pass the value through to connected downstream parameters!
+            # Set incoming_connection_source fields to identify this as legitimate upstream value propagation
+            # (not manual property setting) so it bypasses the INPUT+PROPERTY connection blocking logic
             conn_output_nodes = parent_flow.get_connected_output_parameters(node, parameter)
             for target_node, target_parameter in conn_output_nodes:
                 # Skip propagation for Control Parameters as they should not receive values
@@ -1608,6 +1659,8 @@ class NodeManager:
                             node_name=target_node.name,
                             value=finalized_value,
                             data_type=object_type,  # Do type instead of output type, because it hasn't been processed.
+                            incoming_connection_source_node_name=node.name,
+                            incoming_connection_source_parameter_name=parameter.name,
                         )
                     )
 
@@ -1633,8 +1686,11 @@ class NodeManager:
             node.parameter_output_values[request.parameter_name] = object_created
             return NodeManager.ModifiedReturnValue(object_created, modified)
         # Otherwise use set_parameter_value. This calls our converters and validators.
+        # Skip before_value_set since we already called it earlier in the flow
         old_value = node.get_parameter_value(request.parameter_name)
-        node.set_parameter_value(request.parameter_name, object_created, initial_setup=request.initial_setup)
+        node.set_parameter_value(
+            request.parameter_name, object_created, initial_setup=request.initial_setup, skip_before_value_set=True
+        )
         # Get the "converted" value here.
         finalized_value = node.get_parameter_value(request.parameter_name)
         if old_value != finalized_value:
@@ -1867,7 +1923,7 @@ class NodeManager:
             raise KeyError(msg)
         return self._name_to_parent_flow_name[node_name]
 
-    def on_resolve_from_node_request(self, request: ResolveNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0915, PLR0912
+    async def on_resolve_from_node_request(self, request: ResolveNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0915, PLR0912
         node_name = request.node_name
         debug_mode = request.debug_mode
 
@@ -1935,7 +1991,7 @@ class NodeManager:
             logger.error(details)
             return StartFlowResultFailure(validation_exceptions=[e], result_details=details)
         try:
-            GriptapeNodes.FlowManager().resolve_singular_node(flow, node, debug_mode)
+            await GriptapeNodes.FlowManager().resolve_singular_node(flow, node, debug_mode)
         except Exception as e:
             details = f'Failed to resolve "{node_name}".  Error: {e}'
             logger.error(details)
@@ -2636,6 +2692,12 @@ class NodeManager:
             logger.error(details)
             return RenameParameterResultFailure(result_details=details)
 
+        # Only allow parameter rename for user-defined params
+        if not parameter.user_defined:
+            details = f"Attempted to rename Parameter '{request.parameter_name}' on Node '{node_name}'. Failed because the Parameter is not user-defined."
+            logger.error(details)
+            return RenameParameterResultFailure(result_details=details)
+
         # 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."
@@ -2765,3 +2827,16 @@ class NodeManager:
             response=callback_result.response,
             altered_workflow_state=callback_result.altered_workflow_state,
         )
+
+    def on_get_flow_for_node_request(self, request: GetFlowForNodeRequest) -> ResultPayload:
+        """Get the flow name that contains a specific node."""
+        try:
+            flow_name = self.get_node_parent_flow_by_name(request.node_name)
+            return GetFlowForNodeResultSuccess(
+                flow_name=flow_name,
+                result_details=f"Successfully retrieved flow '{flow_name}' for node '{request.node_name}'.",
+            )
+        except KeyError:
+            return GetFlowForNodeResultFailure(
+                result_details=f"Node '{request.node_name}' not found or not assigned to any flow.",
+            )

griptape_nodes/retained_mode/managers/object_manager.py

@@ -143,6 +143,10 @@ class ObjectManager:
                 context_mgr.pop_flow()
             context_mgr.pop_workflow()
         context_mgr._clipboard.clear()
+
+        # Clear all local workflow variables
+        GriptapeNodes.VariablesManager().on_clear_object_state()
+
         details = "Successfully cleared all object state (deleted everything)."
         logger.debug(details)
         return ClearAllObjectStateResultSuccess()

griptape_nodes/retained_mode/managers/settings.py

@@ -75,6 +75,7 @@ class Settings(BaseModel):
             "Exa": {"EXA_API_KEY": "$EXA_API_KEY"},
             "Grok": {"GROK_API_KEY": "$GROK_API_KEY"},
             "Groq": {"GROQ_API_KEY": "$GROQ_API_KEY"},
+            "Nvidia": {"NVIDIA_API_KEY": "$NVIDIA_API_KEY"},
             "Google": {"GOOGLE_API_KEY": "$GOOGLE_API_KEY", "GOOGLE_API_SEARCH_ID": "$GOOGLE_API_SEARCH_ID"},
             "Huggingface": {"HUGGINGFACE_HUB_ACCESS_TOKEN": "$HUGGINGFACE_HUB_ACCESS_TOKEN"},
             "LeonardoAI": {"LEONARDO_API_KEY": "$LEONARDO_API_KEY"},

griptape_nodes/retained_mode/managers/sync_manager.py

@@ -24,6 +24,7 @@ from griptape_nodes.retained_mode.events.workflow_events import (
     RegisterWorkflowsFromConfigRequest,
     RegisterWorkflowsFromConfigResultSuccess,
 )
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
 if TYPE_CHECKING:
     from griptape_nodes.retained_mode.events.base_events import ResultPayload
@@ -167,8 +168,6 @@ class SyncManager:
             sync_request = StartSyncAllCloudWorkflowsRequest()
 
             # Use handle_request to process through normal event system
-            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
             result = GriptapeNodes.handle_request(sync_request)
 
             if isinstance(result, StartSyncAllCloudWorkflowsResultSuccess):
@@ -193,8 +192,6 @@ class SyncManager:
         Raises:
             RuntimeError: If required cloud configuration is missing.
         """
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
         secrets_manager = GriptapeNodes.SecretsManager()
 
         # Get cloud storage configuration from secrets
@@ -428,8 +425,6 @@ class SyncManager:
         self, sync_id: str, workflow_files: list[str], storage_driver: GriptapeCloudStorageDriver, sync_dir: Path
     ) -> None:
         """Background thread function to sync workflows."""
-        from griptape_nodes.app.app import event_queue
-
         synced_workflows = []
         failed_downloads = []
         total_workflows = len(workflow_files)
@@ -470,14 +465,13 @@ class SyncManager:
             failed_workflows=failed_downloads,
             total_workflows=total_workflows,
         )
-        event_queue.put(AppEvent(payload=sync_complete_event))
+
+        GriptapeNodes.EventManager().put_event(AppEvent(payload=sync_complete_event))
 
         # Register workflows from the synced directory
         if synced_workflows:
             logger.info("Registering %d synced workflows from configuration", len(synced_workflows))
             try:
-                from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
                 register_request = RegisterWorkflowsFromConfigRequest(
                     config_section="app_events.on_app_initialization_complete.workflows_to_register"
                 )