griptape-nodes 0.48.0__py3-none-any.whl → 0.50.0__py3-none-any.whl

griptape_nodes/__init__.py

@@ -32,7 +32,13 @@ with console.status("Loading Griptape Nodes...") as status:
     from griptape_nodes.retained_mode.managers.os_manager import OSManager
     from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
     from griptape_nodes.utils.uv_utils import find_uv_bin
-    from griptape_nodes.utils.version_utils import get_complete_version_string, get_current_version, get_install_source
+    from griptape_nodes.utils.version_utils import (
+        get_complete_version_string,
+        get_current_version,
+        get_install_source,
+        get_latest_version_git,
+        get_latest_version_pypi,
+    )
 
 CONFIG_DIR = xdg_config_home() / "griptape_nodes"
 DATA_DIR = xdg_data_home() / "griptape_nodes"
@@ -642,38 +648,11 @@ def _get_latest_version(package: str, install_source: str) -> str:
         str: Latest release tag (e.g., "v0.31.4")
     """
     if install_source == "pypi":
-        update_url = PYPI_UPDATE_URL.format(package=package)
-
-        with httpx.Client() as client:
-            response = client.get(update_url)
-            try:
-                response.raise_for_status()
-                data = response.json()
-                return f"v{data['info']['version']}"
-            except httpx.HTTPStatusError as e:
-                console.print(f"[red]Error fetching latest version: {e}[/red]")
-                return get_current_version()
-    elif install_source == "git":
-        # We only install auto updating from the 'latest' tag
-        revision = LATEST_TAG
-        update_url = GITHUB_UPDATE_URL.format(package=package, revision=revision)
-
-        with httpx.Client() as client:
-            response = client.get(update_url)
-            try:
-                response.raise_for_status()
-                # Get the latest commit SHA for the tag, this effectively the latest version of the package
-                data = response.json()
-                if "object" in data and "sha" in data["object"]:
-                    return data["object"]["sha"][:7]
-                # Should not happen, but if it does, return the current version
-                return get_current_version()
-            except httpx.HTTPStatusError as e:
-                console.print(f"[red]Error fetching latest version: {e}[/red]")
-                return get_current_version()
-    else:
-        # If the package is installed from a file, just return the current version since the user is likely managing it manually
-        return get_current_version()
+        return get_latest_version_pypi(package, PYPI_UPDATE_URL)
+    if install_source == "git":
+        return get_latest_version_git(package, GITHUB_UPDATE_URL, LATEST_TAG)
+    # If the package is installed from a file, just return the current version since the user is likely managing it manually
+    return get_current_version()
 
 
 def _auto_update_self() -> None:

griptape_nodes/app/app.py

@@ -92,7 +92,6 @@ def start_app() -> None:
     Starts the event loop and listens for events from the Nodes API.
     """
     _init_event_listeners()
-
     # Listen for any signals to exit the app
     for sig in (signal.SIGINT, signal.SIGTERM):
         signal.signal(sig, lambda *_: sys.exit(0))
@@ -100,11 +99,9 @@ def start_app() -> None:
     api_key = _ensure_api_key()
     threading.Thread(target=mcp_server, args=(api_key,), daemon=True).start()
     threading.Thread(target=_listen_for_api_events, args=(api_key,), daemon=True).start()
-
     if STATIC_SERVER_ENABLED:
         static_dir = _build_static_dir()
         threading.Thread(target=start_api, args=(static_dir, event_queue), daemon=True).start()
-
     _process_event_queue()
 
 
@@ -263,8 +260,12 @@ def _process_event_queue() -> None:
     Event queue will be populated by background threads listening for events from the Nodes API.
     """
     # Wait for WebSocket connection to be established before processing events
-    ws_ready_event.wait()
-
+    timed_out = ws_ready_event.wait(timeout=15)
+    if not timed_out:
+        console.print(
+            "[red] The connection to the websocket timed out. Please check your internet connection or the status of Griptape Nodes API.[/red]"
+        )
+        sys.exit(1)
     while True:
         event = event_queue.get(block=True)
         if isinstance(event, EventRequest):

griptape_nodes/bootstrap/workflow_executors/local_workflow_executor.py

@@ -92,7 +92,7 @@ class LocalWorkflowExecutor(WorkflowExecutor):
             node_name = result_event.payload.node_name
             flow_name = GriptapeNodes.NodeManager().get_node_parent_flow_by_name(node_name)
             event_request = EventRequest(request=SingleExecutionStepRequest(flow_name=flow_name))
-            GriptapeNodes.handle_request(event_request.request)
+            self.queue.put(event_request)
 
         elif type(result_event.payload).__name__ == "NodeFinishProcessEvent":
             event_log = f"NodeFinishProcessEvent: {result_event.payload}"
@@ -196,7 +196,13 @@ class LocalWorkflowExecutor(WorkflowExecutor):
             try:
                 event = self.queue.get(block=True)
 
-                if isinstance(event, ExecutionGriptapeNodeEvent):
+                if isinstance(event, EventRequest):
+                    # Handle EventRequest objects by processing them through GriptapeNodes
+                    request_payload = event.request
+                    GriptapeNodes.handle_request(
+                        request_payload, response_topic=event.response_topic, request_id=event.request_id
+                    )
+                elif isinstance(event, ExecutionGriptapeNodeEvent):
                     result_event = event.wrapped_event
 
                     if type(result_event.payload).__name__ == "ControlFlowResolvedEvent":
@@ -208,6 +214,8 @@ class LocalWorkflowExecutor(WorkflowExecutor):
                         is_flow_finished = True
                         logger.error(msg)
                         error = LocalExecutorError(msg)
+                else:
+                    logger.info("Unknown event type encountered: %s", type(event))
 
                 self.queue.task_done()
 

griptape_nodes/exe_types/core_types.py

@@ -714,6 +714,10 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
     # During save/load, this value IS still serialized to save its proper state.
     settable: bool = True
 
+    # "serializable" controls whether parameter values should be serialized during save/load operations.
+    # Set to False for parameters containing non-serializable types (ImageDrivers, PromptDrivers, file handles, etc.)
+    serializable: bool = True
+
     user_defined: bool = False
     _allowed_modes: set = field(
         default_factory=lambda: {
@@ -747,6 +751,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         ui_options: dict | None = None,
         *,
         settable: bool = True,
+        serializable: bool = True,
         user_defined: bool = False,
         element_id: str | None = None,
         element_type: str | None = None,
@@ -764,6 +769,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         self.tooltip_as_property = tooltip_as_property
         self.tooltip_as_output = tooltip_as_output
         self.settable = settable
+        self.serializable = serializable
         self.user_defined = user_defined
         if allowed_modes is None:
             self._allowed_modes = {ParameterMode.INPUT, ParameterMode.OUTPUT, ParameterMode.PROPERTY}
@@ -813,6 +819,8 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         our_dict["tooltip_as_property"] = self.tooltip_as_property
 
         our_dict["is_user_defined"] = self.user_defined
+        our_dict["settable"] = self.settable
+        our_dict["serializable"] = self.serializable
         our_dict["ui_options"] = self.ui_options
 
         # Let's bundle up the mode details.

griptape_nodes/exe_types/node_types.py

@@ -4,7 +4,7 @@ import logging
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Generator, Iterable
 from enum import StrEnum, auto
-from typing import Any, TypeVar
+from typing import Any, NamedTuple, TypeVar
 
 from griptape.events import BaseEvent, EventBus
 
@@ -26,12 +26,14 @@ from griptape_nodes.retained_mode.events.base_events import (
     ExecutionEvent,
     ExecutionGriptapeNodeEvent,
     ProgressEvent,
+    RequestPayload,
 )
 from griptape_nodes.retained_mode.events.execution_events import (
     NodeUnresolvedEvent,
     ParameterValueUpdateEvent,
 )
 from griptape_nodes.retained_mode.events.parameter_events import (
+    AddParameterToNodeRequest,
     RemoveElementEvent,
     RemoveParameterFromNodeRequest,
 )
@@ -52,6 +54,23 @@ class NodeResolutionState(StrEnum):
     RESOLVED = auto()
 
 
+class NodeMessageResult(NamedTuple):
+    """Result from a node message callback.
+
+    Attributes:
+        success: True if the message was handled successfully, False otherwise
+        details: Human-readable description of what happened
+        response: Optional response data to return to the sender
+        altered_workflow_state: True if the message handling altered workflow state.
+            Clients can use this to determine if the workflow needs to be re-saved.
+    """
+
+    success: bool
+    details: str
+    response: Any = None
+    altered_workflow_state: bool = True
+
+
 class BaseNode(ABC):
     # Owned by a flow
     name: str
@@ -148,6 +167,15 @@ class BaseNode(ABC):
         """Callback to confirm allowing a Connection going OUT of this Node."""
         return True
 
+    def before_incoming_connection(
+        self,
+        source_node: BaseNode,  # noqa: ARG002
+        source_parameter_name: str,  # noqa: ARG002
+        target_parameter_name: str,  # noqa: ARG002
+    ) -> None:
+        """Callback before validating a Connection coming TO this Node."""
+        return
+
     def after_incoming_connection(
         self,
         source_node: BaseNode,  # noqa: ARG002
@@ -157,6 +185,15 @@ class BaseNode(ABC):
         """Callback after a Connection has been established TO this Node."""
         return
 
+    def before_outgoing_connection(
+        self,
+        source_parameter_name: str,  # noqa: ARG002
+        target_node: BaseNode,  # noqa: ARG002
+        target_parameter_name: str,  # noqa: ARG002
+    ) -> None:
+        """Callback before validating a Connection going OUT of this Node."""
+        return
+
     def after_outgoing_connection(
         self,
         source_parameter: Parameter,  # noqa: ARG002
@@ -251,6 +288,31 @@ class BaseNode(ABC):
         """Callback for when a Griptape Event comes destined for this Node."""
         return
 
+    def on_node_message_received(
+        self,
+        optional_element_name: str | None,  # noqa: ARG002
+        message_type: str,
+        message: Any,  # noqa: ARG002
+    ) -> NodeMessageResult:
+        """Callback for when a message is sent directly to this node.
+
+        Custom nodes may elect to override this method to handle specific message types
+        and implement custom communication patterns with external systems.
+
+        Args:
+            optional_element_name: Optional element name this message relates to
+            message_type: String indicating the message type for parsing
+            message: Message payload of any type
+
+        Returns:
+            NodeMessageResult: Result containing success status, details, and optional response
+        """
+        return NodeMessageResult(
+            success=False,
+            details=f"Node '{self.name}' was sent a message of type '{message_type}'. Failed because no message handler was specified for this node. Implement the on_node_message_received method in this node class in order for it to receive messages.",
+            response=None,
+        )
+
     def does_name_exist(self, param_name: str) -> bool:
         for parameter in self.parameters:
             if parameter.name == param_name:
@@ -1070,6 +1132,218 @@ class EndLoopNode(BaseNode):
     """Creating class for Start Loop Node in order to implement loop functionality in execution."""
 
 
+class ErrorProxyNode(BaseNode):
+    """A proxy node that substitutes for nodes that failed to create due to missing dependencies or errors.
+
+    This node maintains the original node type information and allows workflows to continue loading
+    even when some node types are unavailable. It generates parameters dynamically as connections
+    and values are assigned to maintain workflow structure.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        original_node_type: str,
+        original_library_name: str,
+        failure_reason: str,
+        metadata: dict[Any, Any] | None = None,
+    ) -> None:
+        super().__init__(name, metadata)
+
+        self.original_node_type = original_node_type
+        self.original_library_name = original_library_name
+        self.failure_reason = failure_reason
+        # Record ALL initial_setup=True requests in order for 1:1 replay
+        self._recorded_initialization_requests: list[RequestPayload] = []
+
+        # Track if user has made connection modifications after initial setup
+        self._has_connection_modifications: bool = False
+
+        # Add error message parameter explaining the failure
+        self._error_message = ParameterMessage(
+            name="error_proxy_message",
+            variant="error",
+            value="",  # Will be set by _update_error_message
+        )
+        self.add_node_element(self._error_message)
+        self._update_error_message()
+
+    def _get_base_error_message(self) -> str:
+        """Generate the base error message for this ErrorProxyNode."""
+        return (
+            f"This is a placeholder for a node of type '{self.original_node_type}'"
+            f"\nfrom the '{self.original_library_name}' library."
+            f"\nIt encountered a problem when loading."
+            f"\nThe technical issue:\n{self.failure_reason}\n\n"
+            f"Your original node will be restored once the issue above is fixed"
+            f"(which may require registering the appropriate library, or getting"
+            f"a code fix from the node author)."
+        )
+
+    def on_attempt_set_parameter_value(self, param_name: str) -> None:
+        """Public method to attempt setting a parameter value during initial setup.
+
+        Creates a PROPERTY mode parameter if it doesn't exist to support value setting.
+
+        Args:
+            param_name: Name of the parameter to prepare for value setting
+        """
+        self._ensure_parameter_exists(param_name)
+
+    def _ensure_parameter_exists(self, param_name: str) -> None:
+        """Ensures a parameter exists on this node.
+
+        Creates a universal parameter with all modes enabled for maximum flexibility.
+        Auto-generated parameters are marked as non-user-defined so they don't get serialized.
+
+        Args:
+            param_name: Name of the parameter to ensure exists
+        """
+        existing_param = super().get_parameter_by_name(param_name)
+
+        if existing_param is None:
+            # Create new universal parameter with all modes enabled
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+            request = AddParameterToNodeRequest(
+                node_name=self.name,
+                parameter_name=param_name,
+                type=ParameterTypeBuiltin.ANY.value,  # ANY = parameter's main type for maximum flexibility
+                input_types=[ParameterTypeBuiltin.ANY.value],  # ANY = accepts any single input type
+                output_type=ParameterTypeBuiltin.ALL.value,  # ALL = can output any type (passthrough)
+                tooltip="Parameter created for placeholder node to preserve workflow connections",
+                mode_allowed_input=True,  # Enable all modes upfront
+                mode_allowed_output=True,
+                mode_allowed_property=True,
+                is_user_defined=False,  # Don't serialize this parameter
+                initial_setup=True,  # Allows setting non-settable parameters and prevents resolution cascades during workflow loading
+            )
+            result = GriptapeNodes.handle_request(request)
+
+            # Check if parameter creation was successful
+            from griptape_nodes.retained_mode.events.parameter_events import AddParameterToNodeResultSuccess
+
+            if not isinstance(result, AddParameterToNodeResultSuccess):
+                failure_message = f"Failed to create parameter '{param_name}': {result.result_details}"
+                raise RuntimeError(failure_message)
+        # If parameter already exists, nothing to do - it already has all modes
+
+    def allow_incoming_connection(
+        self,
+        source_node: BaseNode,  # noqa: ARG002
+        source_parameter: Parameter,  # noqa: ARG002
+        target_parameter: Parameter,  # noqa: ARG002
+    ) -> bool:
+        """ErrorProxyNode allows connections - it's a shell for maintaining connections."""
+        return True
+
+    def allow_outgoing_connection(
+        self,
+        source_parameter: Parameter,  # noqa: ARG002
+        target_node: BaseNode,  # noqa: ARG002
+        target_parameter: Parameter,  # noqa: ARG002
+    ) -> bool:
+        """ErrorProxyNode allows connections - it's a shell for maintaining connections."""
+        return True
+
+    def before_incoming_connection(
+        self,
+        source_node: BaseNode,  # noqa: ARG002
+        source_parameter_name: str,  # noqa: ARG002
+        target_parameter_name: str,
+    ) -> None:
+        """Create target parameter before connection validation."""
+        self._ensure_parameter_exists(target_parameter_name)
+
+    def before_outgoing_connection(
+        self,
+        source_parameter_name: str,
+        target_node: BaseNode,  # noqa: ARG002
+        target_parameter_name: str,  # noqa: ARG002
+    ) -> None:
+        """Create source parameter before connection validation."""
+        self._ensure_parameter_exists(source_parameter_name)
+
+    def set_post_init_connections_modified(self) -> None:
+        """Mark that user-initiated connections have been modified and update the warning message."""
+        if not self._has_connection_modifications:
+            self._has_connection_modifications = True
+            self._update_error_message()
+
+    def _update_error_message(self) -> None:
+        """Update the ParameterMessage to include connection modification warning."""
+        # Build the updated message with connection warning
+        base_message = self._get_base_error_message()
+
+        # Add connection modification warning if applicable
+        if self._has_connection_modifications:
+            connection_warning = (
+                "\n\nWARNING: You have modified connections to this placeholder node."
+                "\nThis may require manual fixes when the original node is restored."
+            )
+            final_message = base_message + connection_warning
+        else:
+            # Add the general note only if no modifications have been made
+            general_warning = (
+                "\n\nNote: Making changes to this node may require manual fixes when restored,"
+                "\nas we can't predict how all node authors craft their custom nodes."
+            )
+            final_message = base_message + general_warning
+
+        # Update the error message value
+        self._error_message.value = final_message
+
+    def validate_before_node_run(self) -> list[Exception] | None:
+        """Prevent ErrorProxy nodes from running - validate at node level only."""
+        error_msg = (
+            f"Cannot run node '{self.name}': This is a placeholder node put in place to preserve your workflow until the breaking issue is fixed.\n\n"
+            f"The original '{self.original_node_type}' from library '{self.original_library_name}' failed to load due to this technical issue:\n\n"
+            f"{self.failure_reason}\n\n"
+            f"Once you resolve the issue above, reload this workflow and the placeholder will be automatically replaced with the original node."
+        )
+        return [RuntimeError(error_msg)]
+
+    def record_initialization_request(self, request: RequestPayload) -> None:
+        """Record an initialization request for replay during serialization.
+
+        This method captures requests that modify ErrorProxyNode structure during workflow loading,
+        preserving information needed for restoration when the original node becomes available.
+
+        WHAT WE RECORD:
+        - AlterParameterDetailsRequest: Parameter modifications from original node definition
+        - Any request with initial_setup=True that changes node structure in ways that cannot
+          be reconstructed from final state alone
+
+        WHAT WE DO NOT RECORD (and why):
+        - SetParameterValueRequest: Final parameter values are serialized normally via parameter_values
+        - AddParameterToNodeRequest: User-defined parameters are serialized via is_user_defined=True flag
+        - CreateConnectionRequest: Connections are serialized separately and recreated during loading
+        - RenameParameterRequest: Final parameter names are preserved in serialized state
+        - SetNodeMetadataRequest: Final metadata state is preserved in node.metadata
+        - SetLockNodeStateRequest: Final lock state is preserved in node.lock
+        """
+        self._recorded_initialization_requests.append(request)
+
+    def get_recorded_initialization_requests(self, request_type: type | None = None) -> list[RequestPayload]:
+        """Get recorded initialization requests for 1:1 serialization replay.
+
+        Args:
+            request_type: Optional class to filter by. If provided, only returns requests
+                         of that type. If None, returns all recorded requests.
+
+        Returns:
+            List of recorded requests in the order they were received.
+        """
+        if request_type is None:
+            return self._recorded_initialization_requests
+
+        return [req for req in self._recorded_initialization_requests if isinstance(req, request_type)]
+
+    def process(self) -> Any:
+        """No-op process method. Error Proxy nodes do nothing during execution."""
+        return None
+
+
 class Connection:
     source_node: BaseNode
     target_node: BaseNode

griptape_nodes/retained_mode/events/node_events.py

@@ -45,6 +45,7 @@ class CreateNodeRequest(RequestPayload):
         resolution: Initial resolution state (defaults to UNRESOLVED)
         initial_setup: Skip setup work when loading from file (defaults to False)
         set_as_new_context: Set this node as current context after creation (defaults to False)
+        create_error_proxy_on_failure: Create Error Proxy node if creation fails (defaults to True)
 
     Results: CreateNodeResultSuccess (with assigned name) | CreateNodeResultFailure (invalid type, missing library, flow not found)
     """
@@ -60,6 +61,8 @@ class CreateNodeRequest(RequestPayload):
     initial_setup: bool = False
     # When True, this Node will be pushed as the current Node within the Current Context.
     set_as_new_context: bool = False
+    # When True, create an Error Proxy node if the requested node type fails to create
+    create_error_proxy_on_failure: bool = True
 
 
 @dataclass
@@ -677,3 +680,53 @@ class DuplicateSelectedNodesResultFailure(WorkflowNotAlteredMixin, ResultPayload
     Common causes: nodes not found, constraints/conflicts,
     insufficient resources, connection duplication failures.
     """
+
+
+@dataclass
+@PayloadRegistry.register
+class SendNodeMessageRequest(RequestPayload):
+    """Send a message to a specific node.
+
+    Use when: External systems need to signal or send data directly to individual nodes,
+    implementing custom communication patterns, triggering node-specific behaviors.
+
+    Args:
+        node_name: Name of the target node (None for current context node)
+        optional_element_name: Optional element name this message relates to
+        message_type: String indicating message type for receiver parsing
+        message: Message payload of any type
+
+    Results: SendNodeMessageResultSuccess (with response) | SendNodeMessageResultFailure (node not found, handler error)
+    """
+
+    message_type: str
+    message: Any
+    node_name: str | None = None
+    optional_element_name: str | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class SendNodeMessageResultSuccess(ResultPayloadSuccess):
+    """Node message sent and processed successfully.
+
+    Args:
+        response: Optional response data from the node's message handler
+    """
+
+    response: Any = None
+
+
+@dataclass
+@PayloadRegistry.register
+class SendNodeMessageResultFailure(ResultPayloadFailure):
+    """Node message sending failed.
+
+    Common causes: node not found, no current context, message handler error,
+    unsupported message type.
+
+    Args:
+        response: Optional response data from the node's message handler (even on failure)
+    """
+
+    response: Any = None

griptape_nodes/retained_mode/events/parameter_events.py

@@ -40,6 +40,7 @@ class AddParameterToNodeRequest(RequestPayload):
         mode_allowed_input: Whether parameter can be used as input
         mode_allowed_property: Whether parameter can be used as property
         mode_allowed_output: Whether parameter can be used as output
+        is_user_defined: Whether this is a user-defined parameter (affects serialization)
         parent_container_name: Name of parent container if nested
         initial_setup: Skip setup work when loading from file
 
@@ -61,6 +62,7 @@ class AddParameterToNodeRequest(RequestPayload):
     mode_allowed_input: bool = Field(default=True)
     mode_allowed_property: bool = Field(default=True)
     mode_allowed_output: bool = Field(default=True)
+    is_user_defined: bool = Field(default=True)
     parent_container_name: str | None = None
     # initial_setup prevents unnecessary work when we are loading a workflow from a file.
     initial_setup: bool = False

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -14,7 +14,7 @@ from griptape_nodes.exe_types.core_types import (
     ParameterTypeBuiltin,
 )
 from griptape_nodes.exe_types.flow import ControlFlow
-from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState, StartLoopNode, StartNode
+from griptape_nodes.exe_types.node_types import BaseNode, ErrorProxyNode, NodeResolutionState, StartLoopNode, StartNode
 from griptape_nodes.machines.control_flow import CompleteState, ControlFlowMachine
 from griptape_nodes.retained_mode.events.base_events import (
     ExecutionEvent,
@@ -681,6 +681,18 @@ class FlowManager:
 
         # Cross-flow connections are now supported via global connection storage
 
+        # Call before_connection callbacks to allow nodes to prepare parameters
+        source_node.before_outgoing_connection(
+            source_parameter_name=request.source_parameter_name,
+            target_node=target_node,
+            target_parameter_name=request.target_parameter_name,
+        )
+        target_node.before_incoming_connection(
+            source_node=source_node,
+            source_parameter_name=request.source_parameter_name,
+            target_parameter_name=request.target_parameter_name,
+        )
+
         # Now validate the parameters.
         source_param = source_node.get_parameter_by_name(request.source_parameter_name)
         if source_param is None:
@@ -852,6 +864,13 @@ class FlowManager:
                 )
             )
 
+        # Check if either node is ErrorProxyNode and mark connection modification if not initial_setup
+        if not request.initial_setup:
+            if isinstance(source_node, ErrorProxyNode):
+                source_node.set_post_init_connections_modified()
+            if isinstance(target_node, ErrorProxyNode):
+                target_node.set_post_init_connections_modified()
+
         result = CreateConnectionResultSuccess()
 
         return result
@@ -995,6 +1014,12 @@ class FlowManager:
         details = f'Connection "{source_node_name}.{request.source_parameter_name}" to "{target_node_name}.{request.target_parameter_name}" deleted.'
         logger.debug(details)
 
+        # Check if either node is ErrorProxyNode and mark connection modification (deletes are always user-initiated)
+        if isinstance(source_node, ErrorProxyNode):
+            source_node.set_post_init_connections_modified()
+        if isinstance(target_node, ErrorProxyNode):
+            target_node.set_post_init_connections_modified()
+
         result = DeleteConnectionResultSuccess()
         return result
 

griptape_nodes/retained_mode/managers/node_manager.py

@@ -13,10 +13,17 @@ from griptape_nodes.exe_types.core_types import (
     ParameterTypeBuiltin,
 )
 from griptape_nodes.exe_types.flow import ControlFlow
-from griptape_nodes.exe_types.node_types import BaseNode, EndLoopNode, NodeResolutionState, StartLoopNode
+from griptape_nodes.exe_types.node_types import (
+    BaseNode,
+    EndLoopNode,
+    ErrorProxyNode,
+    NodeResolutionState,
+    StartLoopNode,
+)
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.node_library.library_registry import LibraryNameAndVersion, LibraryRegistry
 from griptape_nodes.retained_mode.events.base_events import (
+    ResultDetails,
     ResultPayload,
     ResultPayloadFailure,
 )
@@ -73,6 +80,9 @@ from griptape_nodes.retained_mode.events.node_events import (
     ListParametersOnNodeRequest,
     ListParametersOnNodeResultFailure,
     ListParametersOnNodeResultSuccess,
+    SendNodeMessageRequest,
+    SendNodeMessageResultFailure,
+    SendNodeMessageResultSuccess,
     SerializedNodeCommands,
     SerializedParameterValueTracker,
     SerializedSelectedNodesCommands,
@@ -288,7 +298,30 @@ class NodeManager:
             traceback.print_exc()
             details = f"Could not create Node '{final_node_name}' of type '{request.node_type}': {err}"
             logger.error(details)
-            return CreateNodeResultFailure(result_details=details)
+
+            # Check if we should create an Error Proxy node instead of failing
+            if request.create_error_proxy_on_failure:
+                try:
+                    # Create ErrorProxyNode directly since it needs special initialization
+                    node = ErrorProxyNode(
+                        name=final_node_name,
+                        original_node_type=request.node_type,
+                        original_library_name=request.specific_library_name or "Unknown",
+                        failure_reason=str(err),
+                        metadata=request.metadata,
+                    )
+
+                    logger.warning(
+                        "Created Error Proxy (placeholder) node '%s' to substitute for failed '%s'",
+                        final_node_name,
+                        request.node_type,
+                    )
+                except Exception as proxy_err:
+                    details = f"Failed to create Error Proxy (placeholder) node: {proxy_err}"
+                    logger.error(details)
+                    return CreateNodeResultFailure(result_details=details)
+            else:
+                return CreateNodeResultFailure(result_details=details)
         # Add it to the Flow.
         parent_flow.add_node(node)
 
@@ -873,7 +906,7 @@ class NodeManager:
             input_types=request.input_types,
             output_type=request.output_type,
             default_value=request.default_value,
-            user_defined=True,
+            user_defined=request.is_user_defined,
             tooltip=request.tooltip,
             tooltip_as_input=request.tooltip_as_input,
             tooltip_as_property=request.tooltip_as_property,
@@ -1263,7 +1296,7 @@ class NodeManager:
 
         return None
 
-    def on_alter_parameter_details_request(self, request: AlterParameterDetailsRequest) -> ResultPayload:  # noqa: C901, PLR0911
+    def on_alter_parameter_details_request(self, request: AlterParameterDetailsRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
         node_name = request.node_name
         node = None
 
@@ -1292,6 +1325,24 @@ class NodeManager:
             logger.error(details)
             return AlterParameterDetailsResultFailure(result_details=details)
 
+        # Handle ErrorProxyNode parameter alteration requests
+        if isinstance(node, ErrorProxyNode):
+            if request.initial_setup:
+                # Record the alteration request for serialization replay
+                node.record_initialization_request(request)
+
+                # Early return with warning - we're just preserving the original changes
+                details = f"Parameter '{request.parameter_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."
+                logger.warning(details)
+
+                result_details = ResultDetails(message=details, level="WARNING")
+                return AlterParameterDetailsResultSuccess(result_details=result_details)
+
+            # Reject runtime parameter alterations on ErrorProxy
+            details = f"Cannot modify parameter '{request.parameter_name}' on placeholder node '{node_name}'. This placeholder preserves your workflow structure but doesn't allow parameter modifications, as they could cause issues when the original node is restored."
+            logger.error(details)
+            return AlterParameterDetailsResultFailure(result_details=details)
+
         # Does the Element actually exist on the Node?
         element = node.get_element_by_name_and_type(request.parameter_name)
         if element is None:
@@ -1426,6 +1477,22 @@ class NodeManager:
             logger.error(details)
             return SetParameterValueResultFailure(result_details=details)
 
+        # Handle ErrorProxyNode parameter value requests
+        if isinstance(node, ErrorProxyNode):
+            if request.initial_setup:
+                # For initial_setup, actually create the parameter and set the value
+                # This allows normal serialization to handle it, rather than recording the command
+                node.on_attempt_set_parameter_value(param_name)
+                # Continue with normal parameter value setting logic below
+                logger.debug(
+                    "Created parameter '%s' on ErrorProxyNode '%s' during initial setup", param_name, node_name
+                )
+            else:
+                # Reject runtime parameter value changes on ErrorProxy
+                details = f"Cannot set parameter '{param_name}' on placeholder node '{node_name}'. This placeholder preserves your workflow structure but doesn't allow parameter changes, as they could cause issues when the original node is restored."
+                logger.error(details)
+                return SetParameterValueResultFailure(result_details=details)
+
         # Does the Parameter actually exist on the Node?
         parameter = node.get_parameter_by_name(param_name)
         if parameter is None:
@@ -1885,20 +1952,42 @@ class NodeManager:
             library_used = node.metadata["library"]
             # Get the library metadata so we can get the version.
             library_metadata_request = GetLibraryMetadataRequest(library=library_used)
-            library_metadata_result = GriptapeNodes().handle_request(library_metadata_request)
+            # Call LibraryManager directly to avoid error toasts when library is unavailable (expected for ErrorProxyNode)
+            # Per https://github.com/griptape-ai/griptape-nodes/issues/1940
+            library_metadata_result = GriptapeNodes.LibraryManager().get_library_metadata_request(
+                library_metadata_request
+            )
+
             if not isinstance(library_metadata_result, GetLibraryMetadataResultSuccess):
-                details = f"Attempted to serialize Node '{node_name}' to commands. Failed to get metadata for library '{library_used}'."
-                logger.error(details)
-                return SerializeNodeToCommandsResultFailure(result_details=details)
+                if isinstance(node, ErrorProxyNode):
+                    # For ErrorProxyNode, use descriptive message when original library unavailable
+                    library_version = "<version unavailable; workflow was saved when library was unable to be loaded>"
+                    library_details = LibraryNameAndVersion(library_name=library_used, library_version=library_version)
+                    details = f"Serializing Node '{node_name}' (original type: {node.original_node_type}) with unavailable library '{library_used}'. Saving as ErrorProxy with placeholder version. Fix the missing library and reload the workflow to restore the original node."
+                    logger.warning(details)
+                else:
+                    # For regular nodes, this is still an error
+                    details = f"Attempted to serialize Node '{node_name}' to commands. Failed to get metadata for library '{library_used}'."
+                    logger.error(details)
+                    return SerializeNodeToCommandsResultFailure(result_details=details)
+            else:
+                library_version = library_metadata_result.metadata.library_version
+                library_details = LibraryNameAndVersion(library_name=library_used, library_version=library_version)
 
-            library_version = library_metadata_result.metadata.library_version
-            library_details = LibraryNameAndVersion(library_name=library_used, library_version=library_version)
+            # Handle ErrorProxyNode serialization - serialize as original node type
+
+            if isinstance(node, ErrorProxyNode):
+                serialized_node_type = node.original_node_type
+                serialized_library_name = node.original_library_name
+            else:
+                serialized_node_type = node.__class__.__name__
+                serialized_library_name = library_details.library_name
 
             # Get the creation details.
             create_node_request = CreateNodeRequest(
-                node_type=node.__class__.__name__,
+                node_type=serialized_node_type,
                 node_name=node_name,
-                specific_library_name=library_details.library_name,
+                specific_library_name=serialized_library_name,
                 metadata=copy.deepcopy(node.metadata),
                 # If it is actively resolving, mark as unresolved.
                 resolution=node.state.value,
@@ -1906,20 +1995,42 @@ class NodeManager:
             )
 
             # We're going to compare this node instance vs. a canonical one. Rez that one up.
-            reference_node = type(node)(name="REFERENCE NODE")
+            # For ErrorProxyNode, we can't create a reference node, so skip comparison
+            if isinstance(node, ErrorProxyNode):
+                reference_node = None
+            else:
+                reference_node = type(node)(name="REFERENCE NODE")
 
             # Now creation or alteration of all of the elements.
             element_modification_commands = []
             for parameter in node.parameters:
                 # Create the parameter, or alter it on the existing node
                 if parameter.user_defined:
-                    # Add a user-defined Parameter.
+                    # Always serialize user-defined parameters regardless of node type
+                    param_dict = parameter.to_dict()
+                    param_dict["initial_setup"] = True
+                    add_param_request = AddParameterToNodeRequest.create(**param_dict)
+                    element_modification_commands.append(add_param_request)
+                elif isinstance(node, ErrorProxyNode):
+                    # For ErrorProxyNode, replay all recorded initialization requests for this parameter
+                    recorded_requests = node.get_recorded_initialization_requests()
+                    matching_requests = [
+                        recorded_request
+                        for recorded_request in recorded_requests
+                        if (
+                            hasattr(recorded_request, "parameter_name")
+                            and getattr(recorded_request, "parameter_name", None) == parameter.name
+                        )
+                    ]
+                    element_modification_commands.extend(matching_requests)
+                elif reference_node is None:
+                    # Normal node with no reference - treat all parameters as needing serialization
                     param_dict = parameter.to_dict()
                     param_dict["initial_setup"] = True
                     add_param_request = AddParameterToNodeRequest.create(**param_dict)
                     element_modification_commands.append(add_param_request)
                 else:
-                    # Not user defined. Get any deltas from the values on the reference node.
+                    # Normal node - compare against reference node
                     diff = NodeManager._manage_alter_details(parameter, reference_node)
                     relevant = False
                     for key in diff:
@@ -1934,6 +2045,10 @@ class NodeManager:
 
             # Now assignment of values to all of the parameters.
             set_value_commands = []
+
+            # ErrorProxyNode uses normal parameter serialization now since we create real parameters
+            # Only AlterParameterDetailsRequest commands are recorded and replayed
+            # Normal node - use current parameter values
             for parameter in node.parameters:
                 # SetParameterValueRequest event
                 set_param_value_requests = NodeManager._handle_parameter_value_saving(
@@ -2298,6 +2413,7 @@ class NodeManager:
         value: Any,
         serialized_parameter_value_tracker: SerializedParameterValueTracker,
         unique_parameter_uuid_to_values: dict,
+        parameter: Parameter,
         parameter_name: str,
         node_name: str,
         *,
@@ -2321,8 +2437,10 @@ class NodeManager:
             case SerializedParameterValueTracker.TrackerState.NOT_IN_TRACKER:
                 # This value is new for us.
 
-                # Confirm that the author wants this parameter and/or class to be serialized.
-                # TODO: https://github.com/griptape-ai/griptape-nodes/issues/1179 ID a method for classes and/or parameters to be flagged for NOT serializability.
+                # Check if parameter is marked as non-serializable (e.g., ImageDrivers, PromptDrivers, file handles)
+                if not parameter.serializable:
+                    serialized_parameter_value_tracker.add_as_not_serializable(value_id)
+                    return None
 
                 # Check if we can serialize it.
                 try:
@@ -2403,12 +2521,13 @@ class NodeManager:
                 value=internal_value,
                 serialized_parameter_value_tracker=serialized_parameter_value_tracker,
                 unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+                parameter=parameter,
                 is_output=False,
                 parameter_name=parameter.name,
                 node_name=node.name,
             )
             if internal_command is None:
-                details = f"Attempted to serialize set value for parameter '{parameter.name}' on node '{node.name}'. The set value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializability or mark the parameter as not serializable."
+                details = f"Attempted to serialize set value for parameter '{parameter.name}' on node '{node.name}'. The set value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializability or mark the parameter as not serializable by setting serializable=False when creating the parameter."
                 logger.warning(details)
             else:
                 commands.append(internal_command)
@@ -2417,12 +2536,13 @@ class NodeManager:
                 value=output_value,
                 serialized_parameter_value_tracker=serialized_parameter_value_tracker,
                 unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+                parameter=parameter,
                 is_output=True,
                 parameter_name=parameter.name,
                 node_name=node.name,
             )
             if output_command is None:
-                details = f"Attempted to serialize output value for parameter '{parameter.name}' on node '{node.name}'. The output value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializability or mark the parameter as not serializable."
+                details = f"Attempted to serialize output value for parameter '{parameter.name}' on node '{node.name}'. The output value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializability or mark the parameter as not serializable by setting serializable=False when creating the parameter."
                 logger.warning(details)
             else:
                 commands.append(output_command)
@@ -2533,3 +2653,66 @@ class NodeManager:
                 return SetLockNodeStateResultFailure(result_details=details)
         node.lock = request.lock
         return SetLockNodeStateResultSuccess(node_name=node_name, locked=node.lock)
+
+    def on_send_node_message_request(self, request: SendNodeMessageRequest) -> ResultPayload:
+        """Handle a SendNodeMessageRequest by calling the node's message callback.
+
+        Args:
+            request: The SendNodeMessageRequest containing message details
+
+        Returns:
+            ResultPayload: Success or failure result with callback response
+        """
+        node_name = request.node_name
+        node = None
+
+        if node_name is None:
+            # Get from the current context
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = "Attempted to send message to Node from Current Context. Failed because the Current Context is empty."
+                logger.error(details)
+                return SendNodeMessageResultFailure(result_details=details)
+
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+
+        if node is None:
+            # Find the node by name
+            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 send message to Node '{node_name}', but no such Node was found."
+                logger.error(details)
+                return SendNodeMessageResultFailure(result_details=details)
+
+        # Validate optional_element_name if specified
+        if request.optional_element_name is not None:
+            element = node.root_ui_element.find_element_by_name(request.optional_element_name)
+            if element is None:
+                details = f"Attempted to send message to Node '{node_name}' with element '{request.optional_element_name}', but no such element was found."
+                logger.error(details)
+                return SendNodeMessageResultFailure(result_details=details, altered_workflow_state=False)
+
+        # Call the node's message callback
+        callback_result = node.on_node_message_received(
+            optional_element_name=request.optional_element_name,
+            message_type=request.message_type,
+            message=request.message,
+        )
+
+        if not callback_result.success:
+            details = f"Failed to handle message for Node '{node_name}': {callback_result.details}"
+            logger.warning(details)
+            return SendNodeMessageResultFailure(
+                result_details=callback_result.details,
+                response=callback_result.response,
+                altered_workflow_state=callback_result.altered_workflow_state,
+            )
+
+        details = f"Successfully sent message to Node '{node_name}': {callback_result.details}"
+        logger.debug(details)
+        return SendNodeMessageResultSuccess(
+            result_details=callback_result.details,
+            response=callback_result.response,
+            altered_workflow_state=callback_result.altered_workflow_state,
+        )

griptape_nodes/utils/version_utils.py

@@ -6,6 +6,11 @@ import importlib.metadata
 import json
 from typing import Literal
 
+import httpx
+from rich.console import Console
+
+console = Console()
+
 engine_version = importlib.metadata.version("griptape_nodes")
 
 
@@ -49,3 +54,73 @@ def get_complete_version_string() -> str:
     if commit_id is None:
         return f"{version} ({source})"
     return f"{version} ({source} - {commit_id})"
+
+
+def get_latest_version_pypi(package: str, pypi_url: str) -> str:
+    """Gets the latest version from PyPI.
+
+    Args:
+        package: The name of the package to fetch the latest version for.
+        pypi_url: The PyPI URL template to use.
+
+    Returns:
+        str: Latest release tag (e.g., "v0.31.4") or current version if fetch fails.
+    """
+    version = get_current_version()
+    update_url = pypi_url.format(package=package)
+
+    with httpx.Client(timeout=30.0) as client:
+        try:
+            response = client.get(update_url)
+        except httpx.RequestError as e:
+            console.print(f"[red]Error fetching latest version due to error: [/red][cyan]{e}[/cyan]")
+            console.print(
+                f"[red]Please check your internet connection or if you can access the following update url: [/red] [cyan]{update_url}[/cyan]"
+            )
+            return version
+
+        try:
+            response.raise_for_status()
+            data = response.json()
+            if "info" in data and "version" in data["info"]:
+                version = f"v{data['info']['version']}"
+        except httpx.HTTPStatusError as e:
+            console.print(f"[red]Error fetching latest version: {e}[/red]")
+
+    return version
+
+
+def get_latest_version_git(package: str, github_url: str, latest_tag: str) -> str:
+    """Gets the latest version from Git.
+
+    Args:
+        package: The name of the package to fetch the latest version for.
+        github_url: The GitHub URL template to use.
+        latest_tag: The tag to fetch (usually 'latest').
+
+    Returns:
+        str: Latest commit SHA (first 7 characters) or current version if fetch fails.
+    """
+    version = get_current_version()
+    revision = latest_tag
+    update_url = github_url.format(package=package, revision=revision)
+
+    with httpx.Client(timeout=30.0) as client:
+        try:
+            response = client.get(update_url)
+        except httpx.RequestError as e:
+            console.print(f"[red]Error fetching latest version due to error: [/red][cyan]{e}[/cyan]")
+            console.print(
+                f"[red]Please check your internet connection or if you can access the following update url: [/red] [cyan]{update_url}[/cyan]"
+            )
+            return version
+
+        try:
+            response.raise_for_status()
+            data = response.json()
+            if "object" in data and "sha" in data["object"]:
+                version = data["object"]["sha"][:7]
+        except httpx.HTTPStatusError as e:
+            console.print(f"[red]Error fetching latest version: {e}[/red]")
+
+    return version

{griptape_nodes-0.48.0.dist-info → griptape_nodes-0.50.0.dist-info}/METADATA

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

{griptape_nodes-0.48.0.dist-info → griptape_nodes-0.50.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
-griptape_nodes/__init__.py,sha256=086f45e6ae694a24d828e6a1823376b75b6e64bf05ae95bb7e159bee199bd18e,38501
+griptape_nodes/__init__.py,sha256=ca4ec8ef95679e0a98c8e75a539ee1a6eb00c8bf2d1d88bf0e44edb9b778e192,37367
 griptape_nodes/app/.python-version,sha256=7b55f8e67b5623c4bef3fa691288da9437d79d3aba156de48d481db32ac7d16d,5
 griptape_nodes/app/__init__.py,sha256=0c1f834ec81c3676e6102957128bb0cc686b9a8de01c10965c1f4190f1a97502,90
 griptape_nodes/app/api.py,sha256=46a36af068a4784b0317daede79befd59198320c3934ee1b84c74b297108774f,6925
-griptape_nodes/app/app.py,sha256=764f9ef01e11bd5649bc0b0b3e72c4a7e113b5c94eb2236770152cfd81a0eafa,17747
+griptape_nodes/app/app.py,sha256=4d494cb0e1ba87c288b19a76c01015629c104fdf7a8668b6abf42e6e8baeaade,17984
 griptape_nodes/app/watch.py,sha256=413353c7811b54440276277250d766b3be30edf8eb8c128069dbb52d40e9e962,2064
 griptape_nodes/bootstrap/__init__.py,sha256=10dbf7488cd0f53b6546b835cb87b80a7a01a49685a454a43694c5055f17e4bb,25
 griptape_nodes/bootstrap/workflow_executors/__init__.py,sha256=a728cdf35f9e2ed8f21021582d73ad3028b18a223da818b9c9a95df3a88cec49,34
-griptape_nodes/bootstrap/workflow_executors/local_workflow_executor.py,sha256=c3711f000d42b3ea63558b574d327073fe8645f460337bd45cf1190a6a4113ba,8816
+griptape_nodes/bootstrap/workflow_executors/local_workflow_executor.py,sha256=f09128692368e073d18cc602bcc0c81af8317eb4bfff486b30154262eb45f578,9274
 griptape_nodes/bootstrap/workflow_executors/subprocess_workflow_executor.py,sha256=b610be5ba3b459d1f0f0ee6a01fa104bed225d6081ae1db42626de8c7bc6c90c,3347
 griptape_nodes/bootstrap/workflow_executors/workflow_executor.py,sha256=945000fb96d6cabd8a7f53324b9d2f5f549e1bb976ce66d2adbe7f932c8822ba,417
 griptape_nodes/drivers/__init__.py,sha256=b479a21509fab89c855610b63eba87811507ddddf20eca8c4295aa45ab266aa0,42
@@ -17,9 +17,9 @@ griptape_nodes/drivers/storage/local_storage_driver.py,sha256=3e912fb41fd35a0e5c
 griptape_nodes/drivers/storage/storage_backend.py,sha256=dd0048c2b80f73592b04888f60ba0adacc2120f0e22899e7b9c384772c7bcb77,184
 griptape_nodes/exe_types/__init__.py,sha256=c061b02865fdf9349aad415b5e90ef754fc9ede5c86d64c197f3422ce65af86f,32
 griptape_nodes/exe_types/connections.py,sha256=ffe54dcdfe8a6b2eb6433265497f8b9474d4873f82285f940ec6d92c9d25e969,12435
-griptape_nodes/exe_types/core_types.py,sha256=717894764822cad1cedc893adba82cac334a1070087a36fecaad3c9c3e583962,71043
+griptape_nodes/exe_types/core_types.py,sha256=6cd742f545f89d7eb23aa6fdc10c8e706e035f459a57ae4977a630edee6b9e94,71471
 griptape_nodes/exe_types/flow.py,sha256=a42793af1f32ad480bc3553dc90c42edaaf3263c8fdaf6a0fa91b44132aeb7e3,5716
-griptape_nodes/exe_types/node_types.py,sha256=50ac21cb902277f5e3c42e83c8c16001a6fdbc4c8b6e09f62312204351fe5ec8,47447
+griptape_nodes/exe_types/node_types.py,sha256=7c497246e4673e663e6ce3501bb632db5dbd2d2bc01c0117b064632cdce5f47d,59948
 griptape_nodes/exe_types/type_validator.py,sha256=453cf5bd7d3d8f34291e1a33213309d2c88e6545efb0444386b0298dd68cd563,1120
 griptape_nodes/machines/__init__.py,sha256=bf48e4c2bf8214e2e67c461442f5fc04a40b39dbe14ac03ab685e474770f1941,30
 griptape_nodes/machines/control_flow.py,sha256=ac7e9d4555eb0aa5c30cfa182d4df542e661f24b8871113bb26962de917451d5,9843
@@ -47,10 +47,10 @@ griptape_nodes/retained_mode/events/flow_events.py,sha256=084eda147bc1c98ea28b48
 griptape_nodes/retained_mode/events/generate_request_payload_schemas.py,sha256=3d0d104590140658d22068c1f1085851e4664ab7e62ec27a5d57328092a2d772,1102
 griptape_nodes/retained_mode/events/library_events.py,sha256=f4a54c1c0e556b36377d71089b7d599b2fab278dc0c4d8276b84b354f9b2f0f8,17629
 griptape_nodes/retained_mode/events/logger_events.py,sha256=8d8971ccfa26802b09b8fb49d339d60610fc4097c2f2a0b8c5f0a10e2b95bb28,705
-griptape_nodes/retained_mode/events/node_events.py,sha256=69b90367737ff7fb79f7976a9ff5e438e6bc414cf0d797d9c6481ed2a5e81ac5,25587
+griptape_nodes/retained_mode/events/node_events.py,sha256=9402c9c59b07e3bc4f706361987441a82f9813954d7ab2b007ef671d3fe189dc,27298
 griptape_nodes/retained_mode/events/object_events.py,sha256=7096aa114ef72f37f5451c49ac5a84a65f1e4ebfa00e12a95cacb027ebd50894,2631
 griptape_nodes/retained_mode/events/os_events.py,sha256=5f49a6ca4febe6deaea5a43c7960a50fb276e40897da082c02ec4c6525bd571d,8085
-griptape_nodes/retained_mode/events/parameter_events.py,sha256=9f93c22ff4f9cf192d5f7852caaa43b1eced26b4fafd18d2f65bba0263410ead,18411
+griptape_nodes/retained_mode/events/parameter_events.py,sha256=1607dd828ef4c3bdfef1ee22c3e8fcce33f432028d0e6a230e3a902cb85b9e86,18549
 griptape_nodes/retained_mode/events/payload_registry.py,sha256=abec3152aa7adef84d8fe3e5d491891e706485479f70202b3e830ddca0511042,1691
 griptape_nodes/retained_mode/events/secrets_events.py,sha256=7c2c3738c15fc41f054d9b38c9ba239b59ea36f85c8eda0dca54215fbe7e8e43,4156
 griptape_nodes/retained_mode/events/static_file_events.py,sha256=73c90a92bc403d9c6b13d7ec95da56b7078ad42e13fb5f9d1d6c3fefa4917a13,3764
@@ -65,7 +65,7 @@ griptape_nodes/retained_mode/managers/config_manager.py,sha256=d75b211dc72329f4b
 griptape_nodes/retained_mode/managers/context_manager.py,sha256=0e218d874f5367baec2c4717aaa07d62b87689eb41cb9f4b3c5ec6334381412f,22930
 griptape_nodes/retained_mode/managers/engine_identity_manager.py,sha256=181073ec72412553725cb191740bea0e08a131107f6235aa744c0b3029da7548,4409
 griptape_nodes/retained_mode/managers/event_manager.py,sha256=ac6a1e18ed004d977dc3c1a6d510c7a0e0c363227e5eac6218989d6228c7fd06,7201
-griptape_nodes/retained_mode/managers/flow_manager.py,sha256=d8c5e0a31f0613d2f49bb73a865d651b0d44332ff6ec306f0008090e787cc593,109060
+griptape_nodes/retained_mode/managers/flow_manager.py,sha256=7922e81dc89ca57b7657a9ec9e84dd086165168fe03896e06b13bb7162ee2e16,110336
 griptape_nodes/retained_mode/managers/library_lifecycle/__init__.py,sha256=22aefd5714dd113884c417c559771e26080366a4ba5f73a4cd713d5f015c955c,1340
 griptape_nodes/retained_mode/managers/library_lifecycle/data_models.py,sha256=7ef00fd1569818f1d897f2a0dd12f881d265a6ac9af144efa4ff82e3dafde749,6723
 griptape_nodes/retained_mode/managers/library_lifecycle/library_directory.py,sha256=c44e88de3196c524a452db9979bc24d00bee9083f62732c1378b4daaafcc126d,14758
@@ -79,7 +79,7 @@ griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance/sandb
 griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance.py,sha256=7021abf8c4354655418944d97a960429d5613e00b879b718ae6a6ff2b23755e3,894
 griptape_nodes/retained_mode/managers/library_lifecycle/library_status.py,sha256=2b750407301d098f70a61c816cbc4360fd10e37698be12d9fcfcfbfd2cdc3de7,443
 griptape_nodes/retained_mode/managers/library_manager.py,sha256=c89cf240000f6bcf940a4e3106d968694787f51417ec5f90b1738c0852294f11,98816
-griptape_nodes/retained_mode/managers/node_manager.py,sha256=6710033aa69ae8d4a818b585264737ab14c68fffdb9f59225d889e418c818294,135551
+griptape_nodes/retained_mode/managers/node_manager.py,sha256=1235d54ca8be9b84b59519984c9ac2fe946a51dc43e2659b36b6c1e376b32804,145538
 griptape_nodes/retained_mode/managers/object_manager.py,sha256=b483de02217de29b48a57c4cdbda858104da5dacd1817edf69324b57cef25991,12403
 griptape_nodes/retained_mode/managers/operation_manager.py,sha256=95390c66569a71382d579a15f9817a1c6f31b31f55fcbc17d5e834ef8593b369,20137
 griptape_nodes/retained_mode/managers/os_manager.py,sha256=6cf2580a42404a2b1b5ae03da832825d3aae18469538c76005358e3b5d1699b0,34347
@@ -113,7 +113,7 @@ griptape_nodes/utils/dict_utils.py,sha256=932962e4c39fcd2a2bd1af259977d80554bf35
 griptape_nodes/utils/image_preview.py,sha256=361608aa885117dbdb16958812f64774f2cb3cafc975406f0b846f340b126b5c,4480
 griptape_nodes/utils/metaclasses.py,sha256=4522b202f669a47fe16ccba0994988afc42a3a0d6c618e2e44d7d0c9b0f83bc4,287
 griptape_nodes/utils/uv_utils.py,sha256=64adfb2e669c29fc4c54a91c20ec89df91ce5e057ab05584f42ce028f99a454d,519
-griptape_nodes/utils/version_utils.py,sha256=f601cb158cd089036bec69ed7466d74e524e3dfdeaf1f6692024c7a38b001646,1649
+griptape_nodes/utils/version_utils.py,sha256=63e1c97c95ba271bb3fe33a71f1322cbea6631ab8746763eec13b76a51a6c3e4,4318
 griptape_nodes/version_compatibility/__init__.py,sha256=24ccf5b01ed9b23ea94b54b9b1db0f474927f3db35034b01d24148bf280961fa,74
 griptape_nodes/version_compatibility/versions/__init__.py,sha256=3d64b1336f0b3d47417513c0f7c8f84545afb99e0da9f5f575acb6554e92a8fc,74
 griptape_nodes/version_compatibility/versions/v0_39_0/__init__.py,sha256=db588a945a6c9815b85ac01ec520f458c0099ec62632adac21b0de602f37d5f7,62
@@ -121,7 +121,7 @@ griptape_nodes/version_compatibility/versions/v0_39_0/modified_parameters_set_re
 griptape_nodes/version_compatibility/workflow_versions/__init__.py,sha256=cf95c38248b3a0d072097a72a37e217ec24a16c5a53876c3ea18337d81fdb9b7,52
 griptape_nodes/version_compatibility/workflow_versions/v0_7_0/__init__.py,sha256=2333cf9862bcea1dacc1f1864ce1f255c04894e9e0e928e0590ce56dfde7826a,51
 griptape_nodes/version_compatibility/workflow_versions/v0_7_0/local_executor_argument_addition.py,sha256=f4f725029fcc9b920fb5de728f95d24b9fb1ed062689fbe14e5cb6d02801666a,2018
-griptape_nodes-0.48.0.dist-info/WHEEL,sha256=a51d7af6bb8356f1000fb3d205aba975eca53e14c9e011c620094d822eb4863c,79
-griptape_nodes-0.48.0.dist-info/entry_points.txt,sha256=aaf7afa9ddc155b015e5371a9ed9c09b4a2ea9aa982a1b113b7a641729962d63,82
-griptape_nodes-0.48.0.dist-info/METADATA,sha256=62b03f4479b27f2548ff0dbbb1daf21749fca32f9aad00092d7968b1b24aebc1,4980
-griptape_nodes-0.48.0.dist-info/RECORD,,
+griptape_nodes-0.50.0.dist-info/WHEEL,sha256=76443c98c0efcfdd1191eac5fa1d8223dba1c474dbd47676674a255e7ca48770,79
+griptape_nodes-0.50.0.dist-info/entry_points.txt,sha256=aaf7afa9ddc155b015e5371a9ed9c09b4a2ea9aa982a1b113b7a641729962d63,82
+griptape_nodes-0.50.0.dist-info/METADATA,sha256=461e5adb7bd3203d87800235d546f715d6467b8fb7f28916d95531544f51efcd,4980
+griptape_nodes-0.50.0.dist-info/RECORD,,

{griptape_nodes-0.48.0.dist-info → griptape_nodes-0.50.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.10
+Generator: uv 0.8.12
 Root-Is-Purelib: true
 Tag: py3-none-any