griptape-nodes 0.37.1__py3-none-any.whl → 0.38.0__py3-none-any.whl

griptape_nodes/app/app.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import binascii
 import json
 import logging
@@ -9,11 +10,9 @@ import sys
 import threading
 from pathlib import Path
 from queue import Queue
-from time import sleep
 from typing import Any, cast
 from urllib.parse import urljoin
 
-import httpx
 import uvicorn
 from dotenv import get_key
 from fastapi import FastAPI, HTTPException, Request
@@ -27,10 +26,10 @@ from rich.align import Align
 from rich.console import Console
 from rich.logging import RichHandler
 from rich.panel import Panel
+from websockets.asyncio.client import connect
+from websockets.exceptions import ConnectionClosed, WebSocketException
 from xdg_base_dirs import xdg_config_home
 
-from griptape_nodes.app.nodes_api_socket_manager import NodesApiSocketManager
-
 # This import is necessary to register all events, even if not technically used
 from griptape_nodes.retained_mode.events import app_events, execution_events
 from griptape_nodes.retained_mode.events.base_events import (
@@ -50,6 +49,10 @@ from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 # This is a global event queue that will be used to pass events between threads
 event_queue = Queue()
 
+# Global WebSocket connection for sending events
+ws_connection_for_sending = None
+event_loop = None
+
 # Whether to enable the static server
 STATIC_SERVER_ENABLED = os.getenv("STATIC_SERVER_ENABLED", "true").lower() == "true"
 # Host of the static server
@@ -77,7 +80,7 @@ class EventLogHandler(logging.Handler):
 
 
 # Logger for this module. Important that this is not the same as the griptape_nodes logger or else we'll have infinite log events.
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("griptape_nodes_app")
 console = Console()
 
 
@@ -86,7 +89,7 @@ def start_app() -> None:
 
     Starts the event loop and listens for events from the Nodes API.
     """
-    global socket_manager  # noqa: PLW0603 # Need to initialize the socket lazily here to avoid auth-ing too early
+    _init_event_listeners()
 
     griptape_nodes_logger = logging.getLogger("griptape_nodes")
     # When running as an app, we want to forward all log messages to the event queue so they can be sent to the GUI
@@ -94,11 +97,6 @@ def start_app() -> None:
     griptape_nodes_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
     griptape_nodes_logger.setLevel(logging.INFO)
 
-    # Listen for SSE events from the Nodes API in a separate thread
-    socket_manager = NodesApiSocketManager()
-
-    _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))
@@ -220,45 +218,50 @@ def _init_event_listeners() -> None:
     )
 
 
-def _listen_for_api_events() -> None:
-    """Listen for events from the Nodes API and process them."""
-    init = False
-    endpoint = urljoin(os.getenv("GRIPTAPE_NODES_API_BASE_URL", "https://api.nodes.griptape.ai"), "/api/engines/stream")
+async def _alisten_for_api_requests() -> None:
+    """Listen for events from the Nodes API and process them asynchronously."""
+    global ws_connection_for_sending, event_loop  # noqa: PLW0603
+    event_loop = asyncio.get_running_loop()  # Store the event loop reference
     nodes_app_url = os.getenv("GRIPTAPE_NODES_UI_BASE_URL", "https://nodes.griptape.ai")
-    logger.info("Listening for events from Nodes API at %s", endpoint)
-    while True:
+    logger.info("Listening for events from Nodes API via async WebSocket")
+
+    # Auto reconnect https://websockets.readthedocs.io/en/stable/reference/asyncio/client.html#opening-a-connection
+    connection_stream = __create_async_websocket_connection()
+    initialized = False
+    async for ws_connection in connection_stream:
         try:
-            with httpx.stream("get", endpoint, auth=__build_authorized_request, timeout=None) as response:  # noqa: S113 We intentionally want to never timeout
-                __check_api_key_validity(response)
-
-                response.raise_for_status()
-
-                for line in response.iter_lines():
-                    if line.startswith("data:"):
-                        data = line.removeprefix("data:").strip()
-                        if data == "START":
-                            if not init:
-                                __broadcast_app_initialization_complete(nodes_app_url)
-                                init = True
-                        else:
-                            try:
-                                event = json.loads(data)
-                                # With heartbeat events, we skip the regular processing and just send the heartbeat
-                                # Technically no longer needed since https://github.com/griptape-ai/griptape-nodes/pull/369
-                                # but we don't have a proper EventRequest for it yet.
-                                if event.get("request_type") == "Heartbeat":
-                                    session_id = GriptapeNodes.get_session_id()
-                                    socket_manager.heartbeat(session_id=session_id, request=event["request"])
-                                else:
-                                    __process_api_event(event)
-                            except Exception:
-                                logger.exception("Error processing event, skipping.")
-
-        except httpx.RemoteProtocolError as e:
-            logger.debug("Server closed connection, this is expected. Reconnecting... %s", e)
+            ws_connection_for_sending = ws_connection  # Store for sending events
+            if not initialized:
+                __broadcast_app_initialization_complete(nodes_app_url)
+                initialized = True
+
+            async for message in ws_connection:
+                try:
+                    data = json.loads(message)
+
+                    payload = data.get("payload", {})
+                    # With heartbeat events, we skip the regular processing and just send the heartbeat
+                    # Technically no longer needed since https://github.com/griptape-ai/griptape-nodes/pull/369
+                    # but we don't have a proper EventRequest for it yet.
+                    if payload.get("request_type") == "Heartbeat":
+                        session_id = GriptapeNodes.get_session_id()
+                        await __send_heartbeat(
+                            session_id=session_id, request=payload["request"], ws_connection=ws_connection
+                        )
+                    else:
+                        __process_api_event(payload)
+                except Exception:
+                    logger.exception("Error processing event, skipping.")
+        except ConnectionClosed:
+            continue
         except Exception as e:
             logger.error("Error while listening for events. Retrying in 2 seconds... %s", e)
-            sleep(2)
+            await asyncio.sleep(2)
+
+
+def _listen_for_api_events() -> None:
+    """Run the async WebSocket listener in an event loop."""
+    asyncio.run(_alisten_for_api_requests())
 
 
 def __process_node_event(event: GriptapeNodeEvent) -> None:
@@ -272,10 +275,9 @@ def __process_node_event(event: GriptapeNodeEvent) -> None:
     else:
         msg = f"Unknown/unsupported result event type encountered: '{type(result_event)}'."
         raise TypeError(msg) from None
-
     # Don't send events over the wire that don't have a request_id set (e.g. engine-internal events)
     event_json = result_event.json()
-    socket_manager.emit(dest_socket, event_json)
+    __schedule_async_task(__emit_message(dest_socket, event_json))
 
 
 def __process_execution_node_event(event: ExecutionGriptapeNodeEvent) -> None:
@@ -297,8 +299,7 @@ def __process_execution_node_event(event: ExecutionGriptapeNodeEvent) -> None:
             msg = "Node start and finish do not match."
             raise KeyError(msg) from None
         GriptapeNodes.EventManager().current_active_node = None
-    # Set the node name here so I am not double importing
-    socket_manager.emit("execution_event", event_json)
+    __schedule_async_task(__emit_message("execution_event", event_json))
 
 
 def __process_progress_event(gt_event: ProgressEvent) -> None:
@@ -310,7 +311,7 @@ def __process_progress_event(gt_event: ProgressEvent) -> None:
             node_name=node_name, parameter_name=gt_event.parameter_name, type=type(gt_event).__name__, value=value
         )
         event_to_emit = ExecutionEvent(payload=payload)
-        socket_manager.emit("execution_event", event_to_emit.json())
+        __schedule_async_task(__emit_message("execution_event", event_to_emit.json()))
 
 
 def __process_app_event(event: AppEvent) -> None:
@@ -318,7 +319,7 @@ def __process_app_event(event: AppEvent) -> None:
     # Let Griptape Nodes broadcast it.
     GriptapeNodes.broadcast_app_event(event.payload)
 
-    socket_manager.emit("app_event", event.json())
+    __schedule_async_task(__emit_message("app_event", event.json()))
 
 
 def _process_event_queue() -> None:
@@ -339,7 +340,8 @@ def _process_event_queue() -> None:
         event_queue.task_done()
 
 
-def __build_authorized_request(request: httpx.Request) -> httpx.Request:
+def __create_async_websocket_connection() -> Any:
+    """Create an async WebSocket connection to the Nodes API."""
     api_key = get_key(xdg_config_home() / "griptape_nodes" / ".env", "GT_CLOUD_API_KEY")
     if api_key is None:
         message = Panel(
@@ -354,33 +356,63 @@ def __build_authorized_request(request: httpx.Request) -> httpx.Request:
         )
         console.print(message)
         sys.exit(1)
-    request.headers.update(
-        {
-            "Accept": "text/event-stream",
-            "Authorization": f"Bearer {api_key}",
-        }
+
+    endpoint = urljoin(
+        os.getenv("GRIPTAPE_NODES_API_BASE_URL", "https://api.nodes.griptape.ai").replace("http", "ws"),
+        "/ws/engines/events?publish_channel=responses&subscribe_channel=requests",
     )
-    return request
 
+    return connect(
+        endpoint,
+        additional_headers={"Authorization": f"Bearer {api_key}"},
+    )
 
-def __check_api_key_validity(response: httpx.Response) -> None:
-    """Check if the API key is valid by checking the response status code.
 
-    If the API key is invalid, print an error message and exit the program.
-    """
-    if response.status_code in {401, 403}:
-        message = Panel(
-            Align.center(
-                "[bold red]Nodes API key is invalid, please run [code]gtn init[/code] with a valid key: [/bold red]"
-                "[code]gtn init --api-key <your key>[/code]\n"
-                "[bold red]You can generate a new key from [/bold red][bold blue][link=https://nodes.griptape.ai]https://nodes.griptape.ai[/link][/bold blue]",
-            ),
-            title="🔑 ❌ Invalid Nodes API Key",
-            border_style="red",
-            padding=(1, 4),
+async def __emit_message(event_type: str, payload: str) -> None:
+    """Send a message via WebSocket asynchronously."""
+    global ws_connection_for_sending  # noqa: PLW0602
+    if ws_connection_for_sending is None:
+        logger.warning("WebSocket connection not available for sending message")
+        return
+
+    try:
+        body = {"type": event_type, "payload": json.loads(payload) if payload else {}}
+        await ws_connection_for_sending.send(json.dumps(body))
+    except WebSocketException as e:
+        logger.error("Error sending event to Nodes API: %s", e)
+    except Exception as e:
+        logger.error("Unexpected error while sending event to Nodes API: %s", e)
+
+
+async def __send_heartbeat(*, session_id: str | None, request: dict, ws_connection: Any) -> None:
+    """Send a heartbeat response via WebSocket."""
+    heartbeat_response = {
+        "request": request,
+        "result": {},
+        "request_type": "Heartbeat",
+        "event_type": "EventResultSuccess",
+        "result_type": "HeartbeatSuccess",
+        **({"session_id": session_id} if session_id is not None else {}),
+    }
+
+    body = {"type": "success_result", "payload": heartbeat_response}
+    try:
+        await ws_connection.send(json.dumps(body))
+        logger.debug(
+            "Responded to heartbeat request with session: %s and request: %s", session_id, request.get("request_id")
         )
-        console.print(message)
-        sys.exit(1)
+    except WebSocketException as e:
+        logger.error("Error sending heartbeat response: %s", e)
+    except Exception as e:
+        logger.error("Unexpected error while sending heartbeat response: %s", e)
+
+
+def __schedule_async_task(coro: Any) -> None:
+    """Schedule an async coroutine to run in the event loop from a sync context."""
+    if event_loop and event_loop.is_running():
+        asyncio.run_coroutine_threadsafe(coro, event_loop)
+    else:
+        logger.warning("Event loop not available for scheduling async task")
 
 
 def __broadcast_app_initialization_complete(nodes_app_url: str) -> None:
@@ -414,7 +446,7 @@ def __broadcast_app_initialization_complete(nodes_app_url: str) -> None:
     console.print(message)
 
 
-def __process_api_event(data: Any) -> None:
+def __process_api_event(data: dict) -> None:
     """Process API events and send them to the event queue."""
     try:
         data["request"]

griptape_nodes/drivers/storage/griptape_cloud_storage_driver.py

@@ -15,18 +15,20 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
     def __init__(
         self,
         *,
-        bucket_id: str | None = None,
+        bucket_id: str,
         base_url: str | None = None,
         api_key: str | None = None,
         headers: dict | None = None,
+        static_files_directory: str | None = None,
     ) -> None:
         """Initialize the GriptapeCloudStorageDriver.
 
         Args:
-            bucket_id: The ID of the bucket to use. If not provided, a new bucket will be provisioned.
+            bucket_id: The ID of the bucket to use. Required.
             base_url: The base URL for the Griptape Cloud API. If not provided, it will be retrieved from the environment variable "GT_CLOUD_BASE_URL" or default to "https://cloud.griptape.ai".
             api_key: The API key for authentication. If not provided, it will be retrieved from the environment variable "GT_CLOUD_API_KEY".
             headers: Additional headers to include in the requests. If not provided, the default headers will be used.
+            static_files_directory: The directory path prefix for static files. If provided, file names will be prefixed with this path.
         """
         self.base_url = (
             base_url if base_url is not None else os.environ.get("GT_CLOUD_BASE_URL", "https://cloud.griptape.ai")
@@ -41,11 +43,26 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
         )
 
         self.bucket_id = bucket_id
+        self.static_files_directory = static_files_directory
+
+    def _get_full_file_path(self, file_name: str) -> str:
+        """Get the full file path including the static files directory prefix.
+
+        Args:
+            file_name: The base file name.
+
+        Returns:
+            The full file path with static files directory prefix if configured.
+        """
+        if self.static_files_directory:
+            return f"{self.static_files_directory}/{file_name}"
+        return file_name
 
     def create_signed_upload_url(self, file_name: str) -> CreateSignedUploadUrlResponse:
-        self._create_asset(file_name)
+        full_file_path = self._get_full_file_path(file_name)
+        self._create_asset(full_file_path)
 
-        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{file_name}")
+        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{full_file_path}")
         try:
             response = httpx.post(url, json={"operation": "PUT"}, headers=self.headers)
             response.raise_for_status()
@@ -59,7 +76,8 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
         return {"url": response_data["url"], "headers": response_data.get("headers", {}), "method": "PUT"}
 
     def create_signed_download_url(self, file_name: str) -> str:
-        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{file_name}")
+        full_file_path = self._get_full_file_path(file_name)
+        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{full_file_path}")
         try:
             response = httpx.post(url, json={"method": "GET"}, headers=self.headers)
             response.raise_for_status()
@@ -83,3 +101,60 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
             raise ValueError(msg) from e
 
         return response.json()["name"]
+
+    @staticmethod
+    def create_bucket(bucket_name: str, *, base_url: str, api_key: str) -> str:
+        """Create a new bucket in Griptape Cloud.
+
+        Args:
+            bucket_name: Name for the bucket.
+            base_url: The base URL for the Griptape Cloud API.
+            api_key: The API key for authentication.
+
+        Returns:
+            The bucket ID of the created bucket.
+
+        Raises:
+            RuntimeError: If bucket creation fails.
+        """
+        headers = {"Authorization": f"Bearer {api_key}"}
+        url = urljoin(base_url, "/api/buckets")
+        payload = {"name": bucket_name}
+
+        try:
+            response = httpx.post(url, json=payload, headers=headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to create bucket '{bucket_name}': {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+        bucket_id = response_data["bucket_id"]
+
+        logger.info("Created new Griptape Cloud bucket '%s' with ID: %s", bucket_name, bucket_id)
+        return bucket_id
+
+    @staticmethod
+    def list_buckets(*, base_url: str, api_key: str) -> list[dict]:
+        """List all buckets in Griptape Cloud.
+
+        Args:
+            base_url: The base URL for the Griptape Cloud API.
+            api_key: The API key for authentication.
+
+        Returns:
+            A list of dictionaries containing bucket information.
+        """
+        headers = {"Authorization": f"Bearer {api_key}"}
+        url = urljoin(base_url, "/api/buckets")
+
+        try:
+            response = httpx.get(url, headers=headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to list buckets: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        return response.json().get("buckets", [])

griptape_nodes/drivers/storage/local_storage_driver.py

@@ -1,4 +1,5 @@
 import logging
+import time
 from urllib.parse import urljoin
 
 import httpx
@@ -46,4 +47,7 @@ class LocalStorageDriver(BaseStorageDriver):
         return {"url": url, "headers": response_data.get("headers", {}), "method": "PUT"}
 
     def create_signed_download_url(self, file_name: str) -> str:
-        return urljoin(self.base_url, f"/static/{file_name}")
+        url = urljoin(self.base_url, f"/static/{file_name}")
+        # Add a cache-busting query parameter to the URL so that the browser always reloads the file
+        cache_busted_url = urljoin(url, f"?t={int(time.time())}")
+        return cache_busted_url

griptape_nodes/exe_types/core_types.py

@@ -164,10 +164,12 @@ class BaseNodeElement:
     element_type: str = field(default_factory=lambda: BaseNodeElement.__name__)
     name: str = field(default_factory=lambda: str(f"{BaseNodeElement.__name__}_{uuid.uuid4().hex}"))
     parent_group_name: str | None = None
+    _changes: dict[str, Any] = field(default_factory=dict)
 
     _children: list[BaseNodeElement] = field(default_factory=list)
     _stack: ClassVar[list[BaseNodeElement]] = []
     _parent: BaseNodeElement | None = field(default=None)
+    _node_context: BaseNode | None = field(default=None)
 
     @property
     def children(self) -> list[BaseNodeElement]:
@@ -199,6 +201,59 @@ class BaseNodeElement:
     def __repr__(self) -> str:
         return f"BaseNodeElement({self.children=})"
 
+    def get_changes(self) -> dict[str, Any]:
+        return self._changes
+
+    @staticmethod
+    def emits_update_on_write(func: Callable) -> Callable:
+        """Decorator for properties that should track changes and emit events."""
+
+        def wrapper(self: BaseNodeElement, *args, **kwargs) -> Callable:
+            # For setters, track the change
+            if len(args) >= 1:  # setter with value
+                old_value = getattr(self, f"{func.__name__}", None) if hasattr(self, f"{func.__name__}") else None
+                result = func(self, *args, **kwargs)
+                new_value = getattr(self, f"{func.__name__}", None) if hasattr(self, f"{func.__name__}") else None
+                # Track change if different
+                if old_value != new_value:
+                    # it needs to be static so we can call these methods.
+                    self._changes[func.__name__] = new_value
+                    if self._node_context is not None and self not in self._node_context._tracked_parameters:
+                        self._node_context._tracked_parameters.append(self)
+                return result
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    def _emit_alter_element_event_if_possible(self) -> None:
+        """Emit an AlterElementEvent if we have node context and the necessary dependencies."""
+        if self._node_context is None:
+            return
+
+        # Import here to avoid circular dependencies
+        from griptape.events import EventBus
+
+        from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent
+        from griptape_nodes.retained_mode.events.parameter_events import AlterElementEvent
+
+        # Create base event data using the existing to_event method
+        # Create a modified event data that only includes changed fields
+        event_data = {
+            # Include base fields that should always be present
+            "element_id": self.element_id,
+            "element_type": self.element_type,
+            "name": self.name,
+            "node_name": self._node_context.name,
+        }
+        event_data.update(self._changes)
+
+        # Publish the event
+        event = ExecutionGriptapeNodeEvent(
+            wrapped_event=ExecutionEvent(payload=AlterElementEvent(element_details=event_data))
+        )
+        EventBus.publish_event(event)
+        self._changes.clear()
+
     def to_dict(self) -> dict[str, Any]:
         """Returns a nested dictionary representation of this node and its children.
 
@@ -228,8 +283,18 @@ class BaseNodeElement:
         if child._parent is not None:
             child._parent.remove_child(child)
         child._parent = self
+        # Propagate node context to children
+        child._node_context = self._node_context
         self._children.append(child)
 
+        # Also propagate to any existing children of the child
+        for grandchild in child.find_elements_by_type(BaseNodeElement, find_recursively=True):
+            grandchild._node_context = self._node_context
+
+        # Emit event if we have node context
+        if self._node_context is not None:
+            self._node_context._emit_parameter_lifecycle_event(child)
+
     def remove_child(self, child: BaseNodeElement | str) -> None:
         ui_elements: list[BaseNodeElement] = [self]
         for ui_element in ui_elements:
@@ -238,6 +303,8 @@ class BaseNodeElement:
                 ui_element._children.remove(child)
                 break
             ui_elements.extend(ui_element._children)
+        if self._node_context is not None and isinstance(child, BaseNodeElement):
+            self._node_context._emit_parameter_lifecycle_event(child, remove=True)
 
     def find_element_by_id(self, element_id: str) -> BaseNodeElement | None:
         if self.element_id == element_id:
@@ -488,7 +555,7 @@ class Parameter(BaseNodeElement):
     tooltip_as_output: str | list[dict] | None = None
     settable: bool = True
     user_defined: bool = False
-    allowed_modes: set = field(
+    _allowed_modes: set = field(
         default_factory=lambda: {
             ParameterMode.OUTPUT,
             ParameterMode.INPUT,
@@ -539,9 +606,9 @@ class Parameter(BaseNodeElement):
         self.settable = settable
         self.user_defined = user_defined
         if allowed_modes is None:
-            self.allowed_modes = {ParameterMode.INPUT, ParameterMode.OUTPUT, ParameterMode.PROPERTY}
+            self._allowed_modes = {ParameterMode.INPUT, ParameterMode.OUTPUT, ParameterMode.PROPERTY}
         else:
-            self.allowed_modes = allowed_modes
+            self._allowed_modes = allowed_modes
 
         if converters is None:
             self._converters = []
@@ -626,6 +693,7 @@ class Parameter(BaseNodeElement):
         return ParameterTypeBuiltin.STR.value
 
     @type.setter
+    @BaseNodeElement.emits_update_on_write
     def type(self, value: str | None) -> None:
         self._custom_setter_for_property_type(value)
 
@@ -659,6 +727,15 @@ class Parameter(BaseNodeElement):
         validators += self._validators
         return validators
 
+    @property
+    def allowed_modes(self) -> set[ParameterMode]:
+        return self._allowed_modes
+
+    @allowed_modes.setter
+    @BaseNodeElement.emits_update_on_write
+    def allowed_modes(self, value: Any) -> None:
+        self._allowed_modes = value
+
     @property
     def ui_options(self) -> dict:
         ui_options = {}
@@ -671,6 +748,7 @@ class Parameter(BaseNodeElement):
         return ui_options
 
     @ui_options.setter
+    @BaseNodeElement.emits_update_on_write
     def ui_options(self, value: dict) -> None:
         self._ui_options = value
 
@@ -689,6 +767,7 @@ class Parameter(BaseNodeElement):
         return [ParameterTypeBuiltin.STR.value]
 
     @input_types.setter
+    @BaseNodeElement.emits_update_on_write
     def input_types(self, value: list[str] | None) -> None:
         self._custom_setter_for_property_input_types(value)
 
@@ -726,6 +805,7 @@ class Parameter(BaseNodeElement):
         return ParameterTypeBuiltin.STR.value
 
     @output_type.setter
+    @BaseNodeElement.emits_update_on_write
     def output_type(self, value: str | None) -> None:
         self._custom_setter_for_property_output_type(value)
 
@@ -777,6 +857,7 @@ class Parameter(BaseNodeElement):
     def is_outgoing_type_allowed(self, target_type: str | None) -> bool:
         return ParameterType.are_types_compatible(source_type=self.output_type, target_type=target_type)
 
+    @BaseNodeElement.emits_update_on_write
     def set_default_value(self, value: Any) -> None:
         self.default_value = value