griptape-nodes 0.54.1__tar.gz → 0.55.1__tar.gz

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.54.1
+Version: 0.55.1
 Summary: Add your description here
 Requires-Dist: griptape>=1.8.2
 Requires-Dist: pydantic>=2.10.6

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.54.1"
+version = "0.55.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/exe_types/core_types.py

@@ -501,18 +501,42 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
         "error": "Error",
         "success": "Success",
         "tip": "Tip",
+        "link": "Link",
+        "docs": "Documentation",
+        "help": "Help",
+        "note": "Note",
+        "none": "",
+    }
+
+    # Define default icons as a class-level constant (based on Lucide icons)
+    DEFAULT_ICONS: ClassVar[dict[str, str]] = {
+        "info": "info",
+        "warning": "alert-triangle",
+        "error": "x-circle",
+        "success": "check-circle",
+        "tip": "lightbulb",
+        "link": "external-link",
+        "docs": "book-open",
+        "help": "help-circle",
+        "note": "sticky-note",
         "none": "",
     }
 
     # Create a type alias using the keys from DEFAULT_TITLES
-    type VariantType = Literal["info", "warning", "error", "success", "tip", "none"]
+    type VariantType = Literal["info", "warning", "error", "success", "tip", "link", "docs", "help", "note", "none"]
+    type ButtonAlignType = Literal["full-width", "left", "center", "right"]
+    type ButtonVariantType = Literal["default", "destructive", "outline", "secondary", "ghost", "link"]
 
     element_type: str = field(default_factory=lambda: ParameterMessage.__name__)
     _variant: VariantType = field(init=False)
     _title: str | None = field(default=None, init=False)
     _value: str = field(init=False)
+    _message_icon: str | None = field(default="__DEFAULT__", init=False)
     _button_link: str | None = field(default=None, init=False)
     _button_text: str | None = field(default=None, init=False)
+    _button_icon: str | None = field(default=None, init=False)
+    _button_variant: ButtonVariantType = field(default="outline", init=False)
+    _button_align: ButtonAlignType = field(default="full-width", init=False)
     _full_width: bool = field(default=False, init=False)
     _ui_options: dict = field(default_factory=dict, init=False)
 
@@ -522,8 +546,12 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
         value: str,
         *,
         title: str | None = None,
+        message_icon: str | None = "__DEFAULT__",
         button_link: str | None = None,
         button_text: str | None = None,
+        button_icon: str | None = None,
+        button_variant: ButtonVariantType = "outline",
+        button_align: ButtonAlignType = "full-width",
         full_width: bool = False,
         ui_options: dict | None = None,
         **kwargs,
@@ -532,8 +560,12 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
         self._variant = variant
         self._title = title
         self._value = value
+        self._message_icon = message_icon
         self._button_link = button_link
         self._button_text = button_text
+        self._button_icon = button_icon
+        self._button_variant = button_variant
+        self._button_align = button_align
         self._full_width = full_width
         self._ui_options = ui_options or {}
 
@@ -591,6 +623,42 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
     def full_width(self, value: bool) -> None:
         self._full_width = value
 
+    @property
+    def message_icon(self) -> str | None:
+        return self._message_icon
+
+    @message_icon.setter
+    @BaseNodeElement.emits_update_on_write
+    def message_icon(self, value: str | None) -> None:
+        self._message_icon = value
+
+    @property
+    def button_icon(self) -> str | None:
+        return self._button_icon
+
+    @button_icon.setter
+    @BaseNodeElement.emits_update_on_write
+    def button_icon(self, value: str | None) -> None:
+        self._button_icon = value
+
+    @property
+    def button_variant(self) -> ButtonVariantType:
+        return self._button_variant
+
+    @button_variant.setter
+    @BaseNodeElement.emits_update_on_write
+    def button_variant(self, value: ButtonVariantType) -> None:
+        self._button_variant = value
+
+    @property
+    def button_align(self) -> ButtonAlignType:
+        return self._button_align
+
+    @button_align.setter
+    @BaseNodeElement.emits_update_on_write
+    def button_align(self, value: ButtonAlignType) -> None:
+        self._button_align = value
+
     @property
     def ui_options(self) -> dict:
         return self._ui_options
@@ -603,23 +671,46 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
     def to_dict(self) -> dict[str, Any]:
         data = super().to_dict()
 
-        # Use class-level default titles
+        # Use class-level default titles and icons
         title = self.title or self.DEFAULT_TITLES.get(str(self.variant), "")
 
+        # Handle message_icon logic:
+        # - "__DEFAULT__" means use the default icon for the variant
+        # - None means explicitly no icon (empty string)
+        # - Any other string means use that icon
+        if self.message_icon == "__DEFAULT__":
+            message_icon = self.DEFAULT_ICONS.get(str(self.variant), "")
+        elif self.message_icon is None:
+            message_icon = ""
+        else:
+            message_icon = self.message_icon
+
+        # Handle button_icon logic:
+        # - None means no icon
+        # - Empty string means no icon
+        # - Any other string means use that icon
+        if self.button_icon is None or self.button_icon == "":
+            button_icon = ""
+        else:
+            button_icon = self.button_icon
+
         # Merge the UI options with the message-specific options
+        # Always include these fields, even if they're None or empty
+        message_ui_options = {
+            "title": title,
+            "variant": self.variant,
+            "message_icon": message_icon,
+            "button_link": self.button_link,
+            "button_text": self.button_text,
+            "button_icon": button_icon,
+            "button_variant": self.button_variant,
+            "button_align": self.button_align,
+            "full_width": self.full_width,
+        }
+
         merged_ui_options = {
             **self.ui_options,
-            **{
-                k: v
-                for k, v in {
-                    "title": title,
-                    "variant": self.variant,
-                    "button_link": self.button_link,
-                    "button_text": self.button_text,
-                    "full_width": self.full_width,
-                }.items()
-                if v is not None
-            },
+            **message_ui_options,
         }
 
         data["name"] = self.name
@@ -986,11 +1077,6 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         for trait in traits:
             ui_options = ui_options | trait.ui_options_for_trait()
         ui_options = ui_options | self._ui_options
-        if self._parent is not None and isinstance(self._parent, ParameterGroup):
-            # Access the field value directly for ParameterGroup
-            parent_ui_options = getattr(self._parent, "ui_options", {})
-            if isinstance(parent_ui_options, dict):
-                ui_options = ui_options | parent_ui_options
         return ui_options
 
     @ui_options.setter

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/exe_types/node_types.py

@@ -335,7 +335,7 @@ class BaseNode(ABC):
             msg = f"Failed to add Parameter `{param.name}`. Parameter names cannot currently any whitespace characters. Please see https://github.com/griptape-ai/griptape-nodes/issues/714 to check the status on a remedy for this issue."
             raise ValueError(msg)
         if self.does_name_exist(param.name):
-            msg = "Cannot have duplicate names on parameters."
+            msg = f"Cannot have duplicate names on parameters. Encountered two instances of '{param.name}'."
             raise ValueError(msg)
         self.add_node_element(param)
         self._emit_parameter_lifecycle_event(param)
@@ -1254,8 +1254,10 @@ class SuccessFailureNode(BaseNode):
 
     def _create_status_parameters(
         self,
+        *,
         result_details_tooltip: str = "Details about the operation result",
         result_details_placeholder: str = "Details on the operation will be presented here.",
+        parameter_group_initially_collapsed: bool = True,
     ) -> None:
         """Create and add standard status output parameters in a collapsible group.
 
@@ -1270,13 +1272,14 @@ class SuccessFailureNode(BaseNode):
         Args:
             result_details_tooltip: Custom tooltip for result_details parameter
             result_details_placeholder: Custom placeholder text for result_details parameter
+            parameter_group_initially_collapsed: Whether the Status group should start collapsed
         """
         # Create status component with OUTPUT modes for SuccessFailureNode
         self.status_component = ExecutionStatusComponent(
             self,
             was_successful_modes={ParameterMode.OUTPUT},
             result_details_modes={ParameterMode.OUTPUT},
-            parameter_group_initially_collapsed=True,
+            parameter_group_initially_collapsed=parameter_group_initially_collapsed,
             result_details_tooltip=result_details_tooltip,
             result_details_placeholder=result_details_placeholder,
         )

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/machines/parallel_resolution.py

@@ -16,11 +16,13 @@ from griptape_nodes.retained_mode.events.base_events import (
     ExecutionGriptapeNodeEvent,
 )
 from griptape_nodes.retained_mode.events.execution_events import (
+    CurrentControlNodeEvent,
     CurrentDataNodeEvent,
     NodeResolvedEvent,
     ParameterValueUpdateEvent,
 )
 from griptape_nodes.retained_mode.events.parameter_events import SetParameterValueRequest
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
 if TYPE_CHECKING:
     from griptape_nodes.common.directed_graph import DirectedGraph
@@ -103,7 +105,7 @@ class ExecuteDagState(State):
         current_node = done_node.node_reference
 
         # Check if node was already resolved (shouldn't happen)
-        if current_node.state == NodeResolutionState.RESOLVED:
+        if current_node.state == NodeResolutionState.RESOLVED and not current_node.lock:
             logger.error(
                 "DUPLICATE COMPLETION DETECTED: Node '%s' was already RESOLVED but handle_done_nodes was called again from network '%s'. This should not happen!",
                 current_node.name,
@@ -129,7 +131,6 @@ class ExecuteDagState(State):
             data_type = parameter.type
             if data_type is None:
                 data_type = ParameterTypeBuiltin.NONE.value
-            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
             await GriptapeNodes.EventManager().aput_event(
                 ExecutionGriptapeNodeEvent(
@@ -149,7 +150,6 @@ class ExecuteDagState(State):
             library_name = library[0]
         else:
             library_name = None
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
         await GriptapeNodes.EventManager().aput_event(
             ExecutionGriptapeNodeEvent(
@@ -169,8 +169,6 @@ class ExecuteDagState(State):
     @staticmethod
     def get_next_control_graph(context: ParallelResolutionContext, node: BaseNode, network_name: str) -> None:
         """Get next control flow nodes and add them to the DAG graph."""
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
         flow_manager = GriptapeNodes.FlowManager()
 
         # Early returns for various conditions
@@ -224,7 +222,11 @@ class ExecuteDagState(State):
                         }
                     )
                 )
-
+                GriptapeNodes.EventManager().put_event(
+                    ExecutionGriptapeNodeEvent(
+                        wrapped_event=ExecutionEvent(payload=CurrentControlNodeEvent(node_name=next_node.name))
+                    )
+                )
             ExecuteDagState._add_and_queue_nodes(context, next_node, network_name)
 
     @staticmethod
@@ -270,8 +272,6 @@ class ExecuteDagState(State):
         Args:
             node_reference (DagOrchestrator.DagNode): The node to collect values for.
         """
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
         current_node = node_reference.node_reference
         connections = GriptapeNodes.FlowManager().get_connections()
 
@@ -447,16 +447,22 @@ class ExecuteDagState(State):
             node_reference.node_reference.state = NodeResolutionState.RESOLVING
 
             # Send an event that this is a current data node:
-            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
             await GriptapeNodes.EventManager().aput_event(
                 ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=CurrentDataNodeEvent(node_name=node)))
             )
-            # Wait for a task to finish
-        done, _ = await asyncio.wait(context.task_to_node.keys(), return_when=asyncio.FIRST_COMPLETED)
-        # Prevent task being removed before return
-        for task in done:
-            context.task_to_node.pop(task)
+
+        # Wait for a task to finish - only if there are tasks running
+        if context.task_to_node:
+            done, _ = await asyncio.wait(context.task_to_node.keys(), return_when=asyncio.FIRST_COMPLETED)
+            # Check for task exceptions and handle them properly
+            for task in done:
+                if task.exception():
+                    # Get the actual exception and re-raise it
+                    exc = task.exception()
+                    context.task_to_node.pop(task)
+                    raise RuntimeError(exc)
+                context.task_to_node.pop(task)
         # Once a task has finished, loop back to the top.
         await ExecuteDagState.pop_done_states(context)
         # Remove all nodes that are done
@@ -538,8 +544,6 @@ class ParallelResolutionMachine(FSM[ParallelResolutionContext]):
 
     async def resolve_node(self, node: BaseNode | None = None) -> None:  # noqa: ARG002
         """Execute the DAG structure using the existing DagBuilder."""
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
         if self.context.dag_builder is None:
             self.context.dag_builder = GriptapeNodes.FlowManager().global_dag_builder
         await self.start(ExecuteDagState)

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/node_library/library_registry.py

@@ -69,6 +69,7 @@ class CategoryDefinition(BaseModel):
     description: str
     color: str
     icon: str
+    group: str | None = None
 
 
 class NodeDefinition(BaseModel):
@@ -179,10 +180,6 @@ class LibraryRegistry(metaclass=SingletonMeta):
                 logger.error(details)
                 return details
 
-            details = f"When registering Node class '{node_class_name}', Nodes with the same class name were already registered from the following Libraries: '{library_collisions}'. This is a collision. If you want to use this Node, you will need to specify the Library name in addition to the Node class name so that it can be disambiguated."
-            logger.warning(details)
-            return details
-
         return None
 
     @classmethod

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/retained_mode/events/execution_events.py

@@ -225,10 +225,12 @@ class GetFlowStateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
     Args:
         control_node: Name of the current control node (if any)
         resolving_node: Name of the node currently being resolved (if any)
+        involved_nodes: Names of nodes that are queued to be executed or have been executed in the current run.
     """
 
     control_nodes: list[str] | None
     resolving_node: list[str] | None
+    involved_nodes: list[str] | None
 
 
 @dataclass

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/retained_mode/managers/flow_manager.py

@@ -1090,14 +1090,17 @@ class FlowManager:
             details = f"Could not get flow state. Error: {err}"
             return GetFlowStateResultFailure(result_details=details)
         try:
-            control_nodes, resolving_nodes = self.flow_state(flow)
+            control_nodes, resolving_nodes, involved_nodes = self.flow_state(flow)
         except Exception as e:
             details = f"Failed to get flow state of flow with name {flow_name}. Exception occurred: {e} "
             logger.exception(details)
             return GetFlowStateResultFailure(result_details=details)
         details = f"Successfully got flow state for flow with name {flow_name}."
         return GetFlowStateResultSuccess(
-            control_nodes=control_nodes, resolving_node=resolving_nodes, result_details=details
+            control_nodes=control_nodes,
+            resolving_node=resolving_nodes,
+            result_details=details,
+            involved_nodes=involved_nodes,
         )
 
     def on_cancel_flow_request(self, request: CancelFlowRequest) -> ResultPayload:
@@ -1713,28 +1716,27 @@ class FlowManager:
                 await machine.start_flow(start_node, debug_mode)
 
     async def resolve_singular_node(self, flow: ControlFlow, node: BaseNode, *, debug_mode: bool = False) -> None:
-        # Set that we are only working on one node right now! no other stepping allowed
+        # We are now going to have different behavior depending on how the node is behaving.
         if self.check_for_existing_running_flow():
-            # If flow already exists, throw an error
-            errormsg = f"This workflow is already in progress. Please wait for the current process to finish before starting {node.name} again."
-            raise RuntimeError(errormsg)
-
-        self._global_single_node_resolution = True
-
-        # Get or create machine
-        self._global_control_flow_machine = ControlFlowMachine(flow.name)
-        self._global_control_flow_machine.context.current_nodes = [node]
-        resolution_machine = self._global_control_flow_machine.resolution_machine
-        resolution_machine.change_debug_mode(debug_mode=debug_mode)
-        node.state = NodeResolutionState.UNRESOLVED
-        # Build the DAG for the node
-        if isinstance(resolution_machine, ParallelResolutionMachine):
-            self._global_dag_builder.add_node_with_dependencies(node)
-            resolution_machine.context.dag_builder = self._global_dag_builder
-        await resolution_machine.resolve_node(node)
-        if resolution_machine.is_complete():
-            self._global_single_node_resolution = False
-            self._global_control_flow_machine.context.current_nodes = []
+            # Now we know something is running, it's ParallelResolutionMachine, and that we are in single_node_resolution.
+            self._global_dag_builder.add_node_with_dependencies(node, node.name)
+        else:
+            # Set that we are only working on one node right now!
+            self._global_single_node_resolution = True
+            # Get or create machine
+            self._global_control_flow_machine = ControlFlowMachine(flow.name)
+            self._global_control_flow_machine.context.current_nodes = [node]
+            resolution_machine = self._global_control_flow_machine.resolution_machine
+            resolution_machine.change_debug_mode(debug_mode=debug_mode)
+            node.state = NodeResolutionState.UNRESOLVED
+            # Build the DAG for the node
+            if isinstance(resolution_machine, ParallelResolutionMachine):
+                self._global_dag_builder.add_node_with_dependencies(node)
+                resolution_machine.context.dag_builder = self._global_dag_builder
+            await resolution_machine.resolve_node(node)
+            if resolution_machine.is_complete():
+                self._global_single_node_resolution = False
+                self._global_control_flow_machine.context.current_nodes = []
 
     async def single_execution_step(self, flow: ControlFlow, change_debug_mode: bool) -> None:  # noqa: FBT001
         # do a granular step
@@ -1792,12 +1794,12 @@ class FlowManager:
             # Clear entry control parameter for new execution
             node.set_entry_control_parameter(None)
 
-    def flow_state(self, flow: ControlFlow) -> tuple[list[str] | None, list[str] | None]:  # noqa: ARG002
+    def flow_state(self, flow: ControlFlow) -> tuple[list[str] | None, list[str] | None, list[str] | None]:  # noqa: ARG002
         if not self.check_for_existing_running_flow():
             msg = "Flow hasn't started."
             raise RuntimeError(msg)
         if self._global_control_flow_machine is None:
-            return None, None
+            return None, None, None
         control_flow_context = self._global_control_flow_machine.context
         current_control_nodes = (
             [control_flow_node.name for control_flow_node in control_flow_context.current_nodes]
@@ -1810,12 +1812,13 @@ class FlowManager:
                 node.node_reference.name
                 for node in control_flow_context.resolution_machine.context.task_to_node.values()
             ]
-            return current_control_nodes, current_resolving_nodes
+            involved_nodes = list(self._global_dag_builder.node_to_reference.keys())
+            return current_control_nodes, current_resolving_nodes, involved_nodes if len(involved_nodes) != 0 else None
         if isinstance(control_flow_context.resolution_machine, SequentialResolutionMachine):
             focus_stack_for_node = control_flow_context.resolution_machine.context.focus_stack
             current_resolving_node = focus_stack_for_node[-1].node.name if len(focus_stack_for_node) else None
-            return current_control_nodes, [current_resolving_node] if current_resolving_node else None
-        return current_control_nodes, None
+            return current_control_nodes, [current_resolving_node] if current_resolving_node else None, None
+        return current_control_nodes, None, None
 
     def get_start_node_from_node(self, flow: ControlFlow, node: BaseNode) -> BaseNode | None:
         # backwards chain in control outputs.

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/retained_mode/managers/library_manager.py

@@ -116,6 +116,7 @@ console = Console()
 
 class LibraryManager:
     SANDBOX_LIBRARY_NAME = "Sandbox Library"
+    LIBRARY_CONFIG_FILENAME = "griptape_nodes_library.json"
 
     @dataclass
     class LibraryInfo:
@@ -480,24 +481,18 @@ class LibraryManager:
         successful_libraries = []
         failed_libraries = []
 
-        # Load metadata from config libraries
-        config_mgr = GriptapeNodes.ConfigManager()
-        user_libraries_section = "app_events.on_app_initialization_complete.libraries_to_register"
-        libraries_to_register: list[str] = config_mgr.get_config_value(user_libraries_section)
+        # Discover library files for metadata loading
+        library_files = self._discover_library_files()
 
-        if libraries_to_register is not None:
-            for library_to_register in libraries_to_register:
-                if library_to_register and library_to_register.endswith(".json"):
-                    # Load metadata for this library file
-                    metadata_request = LoadLibraryMetadataFromFileRequest(file_path=library_to_register)
-                    metadata_result = self.load_library_metadata_from_file_request(metadata_request)
+        # Load metadata for all discovered library files
+        for library_file in library_files:
+            metadata_request = LoadLibraryMetadataFromFileRequest(file_path=str(library_file))
+            metadata_result = self.load_library_metadata_from_file_request(metadata_request)
 
-                    if isinstance(metadata_result, LoadLibraryMetadataFromFileResultSuccess):
-                        successful_libraries.append(metadata_result)
-                    else:
-                        failed_libraries.append(cast("LoadLibraryMetadataFromFileResultFailure", metadata_result))
-                # Note: We skip requirement specifier libraries (non-.json) as they don't have
-                # JSON files we can load metadata from without installation
+            if isinstance(metadata_result, LoadLibraryMetadataFromFileResultSuccess):
+                successful_libraries.append(metadata_result)
+            else:
+                failed_libraries.append(cast("LoadLibraryMetadataFromFileResultFailure", metadata_result))
 
         # Generate sandbox library metadata
         sandbox_result = self._generate_sandbox_library_metadata()
@@ -1504,8 +1499,6 @@ class LibraryManager:
         return node_class
 
     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
         metadata_request = LoadMetadataForAllLibrariesRequest()
         metadata_result = self.load_metadata_for_all_libraries_request(metadata_request)
@@ -1525,9 +1518,6 @@ class LibraryManager:
             )
 
         # Use metadata results to selectively load libraries
-        user_libraries_section = "app_events.on_app_initialization_complete.libraries_to_register"
-
-        # Load libraries that had successful metadata loading
         for library_result in metadata_result.successful_libraries:
             if library_result.library_schema.name == LibraryManager.SANDBOX_LIBRARY_NAME:
                 # Handle sandbox library - use the schema we already have
@@ -1543,7 +1533,7 @@ class LibraryManager:
                 if isinstance(register_result, RegisterLibraryFromFileResultFailure):
                     # Registration failed - the failure info is already recorded in _library_file_path_to_info
                     # by register_library_from_file_request, so we just log it here for visibility
-                    logger.warning(f"Failed to register library from {library_result.file_path}")  # noqa: G004
+                    logger.warning("Failed to register library from %s", library_result.file_path)
 
         # Print 'em all pretty
         self.print_library_load_status()
@@ -2041,3 +2031,42 @@ class LibraryManager:
             "Successfully reloaded all libraries. All object state was cleared and previous libraries were unloaded."
         )
         return ReloadAllLibrariesResultSuccess(result_details=ResultDetails(message=details, level=logging.INFO))
+
+    def _discover_library_files(self) -> list[Path]:
+        """Discover library JSON files from config and workspace recursively.
+
+        Returns:
+            List of library file paths found
+        """
+        config_mgr = GriptapeNodes.ConfigManager()
+        user_libraries_section = "app_events.on_app_initialization_complete.libraries_to_register"
+
+        libraries_to_process = []
+
+        # Add from config
+        config_libraries = config_mgr.get_config_value(user_libraries_section, default=[])
+        libraries_to_process.extend(config_libraries)
+
+        # Add from workspace - recursive discovery of library JSON files
+        workspace_path = config_mgr.workspace_path
+        libraries_to_process.append(str(workspace_path))
+
+        library_files = []
+
+        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
+                library_files.extend(path.rglob(LibraryManager.LIBRARY_CONFIG_FILENAME))
+            elif path.suffix == ".json":
+                library_files.append(path)
+
+        # Process library paths
+        for library_to_process in libraries_to_process:
+            library_path = Path(library_to_process)
+
+            # Handle library config files and directories only (skip requirement specifiers)
+            if library_path.exists():
+                process_path(library_path)
+
+        return library_files

{griptape_nodes-0.54.1 → griptape_nodes-0.55.1}/src/griptape_nodes/retained_mode/managers/node_manager.py

@@ -22,6 +22,7 @@ from griptape_nodes.exe_types.node_types import (
     StartLoopNode,
 )
 from griptape_nodes.exe_types.type_validator import TypeValidator
+from griptape_nodes.machines.sequential_resolution import SequentialResolutionMachine
 from griptape_nodes.node_library.library_registry import LibraryNameAndVersion, LibraryRegistry
 from griptape_nodes.retained_mode.events.base_events import (
     ResultDetails,
@@ -445,7 +446,7 @@ class NodeManager:
             # get the current node executing / resolving
             # if it's in connected nodes, cancel flow.
             # otherwise, leave it.
-            control_node_names, resolving_node_names = GriptapeNodes.FlowManager().flow_state(parent_flow)
+            control_node_names, resolving_node_names, _ = GriptapeNodes.FlowManager().flow_state(parent_flow)
             connected_nodes = parent_flow.get_all_connected_nodes(node)
             cancelled = False
             if control_node_names is not None:
@@ -1856,9 +1857,28 @@ class NodeManager:
         if flow is None:
             details = f'Failed to fetch parent flow for "{node_name}"'
             return ResolveNodeResultFailure(validation_exceptions=[], result_details=details)
-        if GriptapeNodes.FlowManager().check_for_existing_running_flow():
-            details = f"Failed to resolve from node '{node_name}'. Flow is already running."
-            return ResolveNodeResultFailure(validation_exceptions=[], result_details=details)
+
+        # Check for existing running flow
+        flow_mgr = GriptapeNodes.FlowManager()
+        if flow_mgr.check_for_existing_running_flow():
+            # Behavior should stay the same for sequential flows.
+            if flow_mgr._global_control_flow_machine and isinstance(
+                flow_mgr._global_control_flow_machine.resolution_machine, SequentialResolutionMachine
+            ):
+                errormsg = f"This workflow is already in progress. Please wait for the current process to finish before starting {node.name} again."
+                return ResolveNodeResultFailure(validation_exceptions=[RuntimeError(errormsg)], result_details=errormsg)
+            # Behavior should also match if the flow running is a Control Flow, and not a singular node resolution.
+            if not flow_mgr._global_single_node_resolution:
+                errormsg = f"This workflow is already in progress. Please wait for the current control process to finish before starting {node.name} again."
+                return ResolveNodeResultFailure(validation_exceptions=[RuntimeError(errormsg)], result_details=errormsg)
+
+        # Check if the node is already in the DAG - if so, skip this resolution. It's already queued or has been resolved.
+        if node.name in flow_mgr._global_dag_builder.node_to_reference:
+            logger.error("Node %s is already executing. Cannot start execution.", node.name)
+            return ResolveNodeResultFailure(
+                validation_exceptions=[],
+                result_details=f"Node {node.name} is already executing. Cannot start execution.",
+            )
         try:
             GriptapeNodes.FlowManager().get_connections().unresolve_future_nodes(node)
         except Exception as e: