griptape-nodes 0.34.2__py3-none-any.whl → 0.35.0__py3-none-any.whl

griptape_nodes/__init__.py

@@ -9,6 +9,7 @@ with console.status("Loading Griptape Nodes...") as status:
     import argparse
     import importlib.metadata
     import json
+    import os
     import shutil
     import sys
     import tarfile
@@ -61,27 +62,37 @@ def main() -> None:
 
 
 def _run_init(
-    *, api_key: str | None = None, workspace_directory: str | None = None, register_advanced_library: bool | None = None
+    *, workspace_directory: str | None = None, api_key: str | None = None, register_advanced_library: bool | None = None
 ) -> None:
-    """Runs through the engine init steps, optionally skipping prompts if the user provided `--api-key`."""
+    """Runs through the engine init steps.
+
+    Args:
+        workspace_directory (str | None): The workspace directory to set.
+        api_key (str | None): The API key to set.
+        register_advanced_library (bool | None): Whether to register the advanced library.
+    """
     __init_system_config()
-    _prompt_for_workspace(workspace_directory_arg=workspace_directory)
+    _prompt_for_workspace(workspace_directory=workspace_directory)
     _prompt_for_api_key(api_key=api_key)
     _prompt_for_libraries_to_register(register_advanced_library=register_advanced_library)
     _sync_assets()
     console.print("[bold green]Initialization complete![/bold green]")
 
 
-def _start_engine(*, no_update: bool) -> None:
+def _start_engine(*, no_update: bool = False) -> None:
     """Starts the Griptape Nodes engine.
 
     Args:
-        no_update: If True, skips the auto-update check.
+        no_update (bool): If True, skips the auto-update check.
     """
     if not CONFIG_DIR.exists():
         # Default init flow if there is no config directory
         console.print("[bold green]Config directory not found. Initializing...[/bold green]")
-        _run_init()
+        _run_init(
+            workspace_directory=os.getenv("GTN_WORKSPACE_DIRECTORY"),
+            api_key=os.getenv("GTN_API_KEY"),
+            register_advanced_library=os.getenv("GTN_REGISTER_ADVANCED_LIBRARY", "false").lower() == "true",
+        )
 
     # Confusing double negation -- If `no_update` is set, we want to skip the update
     if not no_update:
@@ -115,15 +126,17 @@ def _get_args() -> argparse.Namespace:
     init_parser.add_argument(
         "--api-key",
         help="Set the Griptape Nodes API key.",
+        default=os.getenv("GTN_API_KEY", None),
     )
     init_parser.add_argument(
         "--workspace-directory",
         help="Set the Griptape Nodes workspace directory.",
+        default=os.getenv("GTN_WORKSPACE_DIRECTORY", None),
     )
+    register_advanced_library = os.getenv("GTN_REGISTER_ADVANCED_LIBRARY", None)
     init_parser.add_argument(
         "--register-advanced-library",
-        action="store_true",
-        default=None,
+        default=register_advanced_library.lower() == "true" if register_advanced_library is not None else None,
         help="Install the Griptape Nodes Advanced Image Library.",
     )
 
@@ -181,47 +194,46 @@ def _prompt_for_api_key(api_key: str | None = None) -> None:
         Once the key is generated, copy and paste its value here to proceed."""
         console.print(Panel(explainer, expand=False))
 
-    default_key = api_key or secrets_manager.get_secret("GT_CLOUD_API_KEY", should_error_on_not_found=False)
-    # If api_key is provided via --api-key, we don't want to prompt for it
-    current_key = api_key
-    while current_key is None:
-        current_key = Prompt.ask(
-            "Griptape API Key",
-            default=default_key,
-            show_default=True,
-        )
+        default_api_key = secrets_manager.get_secret("GT_CLOUD_API_KEY", should_error_on_not_found=False)
+        while api_key is None:
+            api_key = Prompt.ask(
+                "Griptape API Key",
+                default=default_api_key,
+                show_default=True,
+            )
 
-    secrets_manager.set_secret("GT_CLOUD_API_KEY", current_key)
+    secrets_manager.set_secret("GT_CLOUD_API_KEY", api_key)
     console.print("[bold green]Griptape API Key set")
 
 
-def _prompt_for_workspace(*, workspace_directory_arg: str | None) -> None:
+def _prompt_for_workspace(*, workspace_directory: str | None) -> None:
     """Prompts the user for their workspace directory and stores it in config directory."""
-    if workspace_directory_arg is None:
+    if workspace_directory is None:
         explainer = """[bold cyan]Workspace Directory[/bold cyan]
         Select the workspace directory. This is the location where Griptape Nodes will store your saved workflows.
         You may enter a custom directory or press Return to accept the default workspace directory"""
         console.print(Panel(explainer, expand=False))
 
-    valid_workspace = False
-    default_workspace_directory = workspace_directory_arg or config_manager.get_config_value("workspace_directory")
-    while not (valid_workspace or workspace_directory_arg):
-        try:
-            workspace_directory = Prompt.ask(
-                "Workspace Directory",
-                default=default_workspace_directory,
-                show_default=True,
-            )
-            workspace_path = Path(workspace_directory).expanduser().resolve()
-
-            config_manager.workspace_path = workspace_path
-            config_manager.set_config_value("workspace_directory", str(workspace_path))
+        default_workspace_directory = workspace_directory or config_manager.get_config_value("workspace_directory")
+        while workspace_directory is None:
+            try:
+                workspace_to_test = Prompt.ask(
+                    "Workspace Directory",
+                    default=default_workspace_directory,
+                    show_default=True,
+                )
+                # Try to resolve the path to check if it exists
+                if workspace_to_test is not None:
+                    Path(workspace_to_test).expanduser().resolve()
+                workspace_directory = workspace_to_test
+            except OSError as e:
+                console.print(f"[bold red]Invalid workspace directory: {e}[/bold red]")
+            except json.JSONDecodeError as e:
+                console.print(f"[bold red]Error reading config file: {e}[/bold red]")
+
+    workspace_path = Path(workspace_directory).expanduser().resolve()
+    config_manager.set_config_value("workspace_directory", str(workspace_path))
 
-            valid_workspace = True
-        except OSError as e:
-            console.print(f"[bold red]Invalid workspace directory: {e}[/bold red]")
-        except json.JSONDecodeError as e:
-            console.print(f"[bold red]Error reading config file: {e}[/bold red]")
     console.print(f"[bold green]Workspace directory set to: {config_manager.workspace_path}[/bold green]")
 
 
@@ -429,6 +441,7 @@ def _uninstall_self() -> None:
     # Remove config and data directories
     console.print("[bold]Removing config and data directories...[/bold]")
     dirs = [(CONFIG_DIR, "Config Dir"), (DATA_DIR, "Data Dir")]
+    caveats = []
     for dir_path, dir_name in dirs:
         if dir_path.exists():
             console.print(f"[bold]Removing {dir_name} '{dir_path}'...[/bold]")
@@ -436,10 +449,12 @@ def _uninstall_self() -> None:
                 shutil.rmtree(dir_path)
             except OSError as exc:
                 console.print(f"[red]Error removing {dir_name} '{dir_path}': {exc}[/red]")
+                caveats.append(
+                    f"- [red]Error removing {dir_name} '{dir_path}'. You may want remove this directory manually.[/red]"
+                )
         else:
             console.print(f"[yellow]{dir_name} '{dir_path}' does not exist; skipping.[/yellow]")
 
-    caveats = []
     # Handle any remaining config files not removed by design
     remaining_config_files = config_manager.config_files
     if remaining_config_files:
@@ -461,8 +476,8 @@ def _uninstall_self() -> None:
 def _process_args(args: argparse.Namespace) -> None:  # noqa: C901, PLR0912
     if args.command == "init":
         _run_init(
-            api_key=args.api_key,
             workspace_directory=args.workspace_directory,
+            api_key=args.api_key,
             register_advanced_library=args.register_advanced_library,
         )
     elif args.command == "engine":
@@ -529,7 +544,7 @@ def __init_system_config() -> None:
     for file_name in files_to_create:
         file_path = CONFIG_DIR / file_name[0]
         if not file_path.exists():
-            with Path.open(file_path, "w") as file:
+            with Path.open(file_path, "w", encoding="utf-8") as file:
                 file.write(file_name[1])
 
 

griptape_nodes/app/app.py

@@ -16,7 +16,7 @@ from urllib.parse import urljoin
 import httpx
 import uvicorn
 from dotenv import get_key
-from fastapi import FastAPI, HTTPException, Request, UploadFile
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from griptape.events import (
@@ -154,15 +154,15 @@ def _serve_static_server() -> None:
         return {"url": url}
 
     @app.put("/static-uploads/{file_name:str}")
-    async def create_static_file(file: UploadFile, file_name: str) -> dict:
+    async def create_static_file(request: Request, file_name: str) -> dict:
         """Upload a static file to the static server."""
         if not STATIC_SERVER_ENABLED:
             msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
             raise ValueError(msg)
 
-        data = await file.read()
         if not static_dir.exists():
             static_dir.mkdir(parents=True, exist_ok=True)
+        data = await request.body()
         try:
             Path(static_dir / file_name).write_bytes(data)
         except binascii.Error as e:

griptape_nodes/bootstrap/bootstrap_script.py

@@ -17,6 +17,7 @@ from register_libraries_script import (  # type: ignore[import] - This import is
     register_libraries,
 )
 
+from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.exe_types.node_types import EndNode, StartNode
 from griptape_nodes.retained_mode.events.base_events import (
     AppEvent,
@@ -63,9 +64,9 @@ def _load_user_workflow(path_to_workflow: str) -> None:
     spec.loader.exec_module(module)
 
 
-def _load_flow_for_workflow() -> str:
+def _load_flow_for_workflow() -> ControlFlow:
     context_manager = GriptapeNodes.ContextManager()
-    return context_manager.get_current_flow_name()
+    return context_manager.get_current_flow()
 
 
 def _set_workflow_context(workflow_name: str) -> None:
@@ -208,7 +209,8 @@ def run(workflow_name: str, flow_input: Any) -> None:
     # or nothing works. The name can be anything, but how about the workflow_name.
     _set_workflow_context(workflow_name=workflow_name)
     _load_user_workflow("workflow.py")
-    flow_name = _load_flow_for_workflow()
+    flow = _load_flow_for_workflow()
+    flow_name = flow.name
     # Now let's set the input to the flow
     _set_input_for_flow(flow_name=flow_name, flow_input=flow_input)
 

griptape_nodes/drivers/__init__.py

@@ -0,0 +1 @@
+"""Package for griptape nodes drivers."""

griptape_nodes/drivers/storage/__init__.py

@@ -0,0 +1,4 @@
+"""Package for griptape nodes storage drivers.
+
+Storage drivers are responsible for managing the storage and retrieval of files.
+"""

griptape_nodes/drivers/storage/base_storage_driver.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from typing import TypedDict
+
+
+class CreateSignedUploadUrlResponse(TypedDict):
+    """Response type for create_signed_upload_url method."""
+
+    url: str
+    headers: dict
+    method: str
+
+
+class BaseStorageDriver(ABC):
+    """Base class for storage drivers."""
+
+    @abstractmethod
+    def create_signed_upload_url(self, file_name: str) -> CreateSignedUploadUrlResponse:
+        """Create a signed upload URL for the given file name.
+
+        Args:
+            file_name: The name of the file to create a signed URL for.
+
+        Returns:
+            CreateSignedUploadUrlResponse: A dictionary containing the signed URL, headers, and operation type.
+        """
+        ...
+
+    @abstractmethod
+    def create_signed_download_url(self, file_name: str) -> str:
+        """Create a signed download URL for the given file name.
+
+        Args:
+            file_name: The name of the file to create a signed URL for.
+
+        Returns:
+            str: The signed URL for downloading the file.
+        """
+        ...

griptape_nodes/drivers/storage/griptape_cloud_storage_driver.py

@@ -0,0 +1,85 @@
+import logging
+import os
+from urllib.parse import urljoin
+
+import httpx
+
+from griptape_nodes.drivers.storage.base_storage_driver import BaseStorageDriver, CreateSignedUploadUrlResponse
+
+logger = logging.getLogger("griptape_nodes")
+
+
+class GriptapeCloudStorageDriver(BaseStorageDriver):
+    """Stores files using the Griptape Cloud's Asset APIs."""
+
+    def __init__(
+        self,
+        *,
+        bucket_id: str | None = None,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        headers: dict | 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.
+            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.
+        """
+        self.base_url = (
+            base_url if base_url is not None else os.environ.get("GT_CLOUD_BASE_URL", "https://cloud.griptape.ai")
+        )
+        self.api_key = api_key if api_key is not None else os.environ.get("GT_CLOUD_API_KEY")
+        self.headers = (
+            headers
+            if headers is not None
+            else {
+                "Authorization": f"Bearer {self.api_key}",
+            }
+        )
+
+        self.bucket_id = bucket_id
+
+    def create_signed_upload_url(self, file_name: str) -> CreateSignedUploadUrlResponse:
+        self._create_asset(file_name)
+
+        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{file_name}")
+        try:
+            response = httpx.post(url, json={"operation": "PUT"}, headers=self.headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to create presigned URL for file {file_name}: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+
+        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}")
+        try:
+            response = httpx.post(url, json={"method": "GET"}, headers=self.headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to create presigned URL for file {file_name}: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+
+        return response_data["url"]
+
+    def _create_asset(self, asset_name: str) -> str:
+        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/assets")
+        try:
+            response = httpx.put(url=url, json={"name": asset_name}, headers=self.headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = str(e)
+            logger.error(msg)
+            raise ValueError(msg) from e
+
+        return response.json()["name"]

griptape_nodes/drivers/storage/local_storage_driver.py

@@ -0,0 +1,49 @@
+import logging
+from urllib.parse import urljoin
+
+import httpx
+
+from griptape_nodes.app.app import STATIC_SERVER_ENABLED, STATIC_SERVER_HOST, STATIC_SERVER_PORT, STATIC_SERVER_URL
+from griptape_nodes.drivers.storage.base_storage_driver import BaseStorageDriver, CreateSignedUploadUrlResponse
+
+logger = logging.getLogger("griptape_nodes")
+
+
+class LocalStorageDriver(BaseStorageDriver):
+    """Stores files using the engine's local static server."""
+
+    def __init__(self, base_url: str | None = None) -> None:
+        """Initialize the LocalStorageDriver.
+
+        Args:
+            base_url: The base URL for the static file server. If not provided, it will be constructed
+        """
+        if not STATIC_SERVER_ENABLED:
+            msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
+            raise ValueError(msg)
+        if base_url is None:
+            self.base_url = f"http://{STATIC_SERVER_HOST}:{STATIC_SERVER_PORT}{STATIC_SERVER_URL}"
+        else:
+            self.base_url = base_url
+
+    def create_signed_upload_url(self, file_name: str) -> CreateSignedUploadUrlResponse:
+        static_url = urljoin(self.base_url, "/static-upload-urls")
+        try:
+            response = httpx.post(static_url, json={"file_name": file_name})
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to create presigned URL for file {file_name}: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+        url = response_data.get("url")
+        if url is None:
+            msg = f"Failed to create presigned URL for file {file_name}: {response_data}"
+            logger.error(msg)
+            raise ValueError(msg)
+
+        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}")

griptape_nodes/exe_types/core_types.py

@@ -5,7 +5,7 @@ from abc import ABC, abstractmethod
 from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, auto
-from typing import TYPE_CHECKING, Any, ClassVar, NamedTuple, Self, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, Self, TypeVar
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -272,6 +272,62 @@ class BaseNodeElement:
         return cls._stack[-1] if cls._stack else None
 
 
+@dataclass(kw_only=True)
+class ParameterMessage(BaseNodeElement):
+    """Represents a UI message element, such as a warning or informational text."""
+
+    # Define default titles as a class-level constant
+    DEFAULT_TITLES: ClassVar[dict[str, str]] = {
+        "info": "Info",
+        "warning": "Warning",
+        "error": "Error",
+        "success": "Success",
+        "tip": "Tip",
+        "none": "",
+    }
+
+    # Create a type alias using the keys from DEFAULT_TITLES
+    type VariantType = Literal["info", "warning", "error", "success", "tip", "none"]
+
+    element_type: str = field(default_factory=lambda: ParameterMessage.__name__)
+    variant: VariantType
+    title: str | None = None
+    value: str
+    button_link: str | None = None
+    button_text: str | None = None
+    full_width: bool = False
+    ui_options: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = super().to_dict()
+
+        # Use class-level default titles
+        title = self.title or self.DEFAULT_TITLES.get(str(self.variant), "")
+
+        # Merge the UI options with the message-specific options
+        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
+            },
+        }
+
+        data["name"] = self.name
+        data["value"] = self.value
+        data["default_value"] = self.value  # for compatibility
+        data["ui_options"] = merged_ui_options
+
+        return data
+
+
 @dataclass(kw_only=True)
 class ParameterGroup(BaseNodeElement):
     """UI element for a group of parameters."""

griptape_nodes/exe_types/flow.py

@@ -30,13 +30,15 @@ class CurrentNodes(NamedTuple):
 
 # The flow will own all of the nodes and the connections
 class ControlFlow:
+    name: str
     connections: Connections
     nodes: dict[str, BaseNode]
     control_flow_machine: ControlFlowMachine
     single_node_resolution: bool
     flow_queue: Queue[BaseNode]
 
-    def __init__(self) -> None:
+    def __init__(self, name: str) -> None:
+        self.name = name
         self.connections = Connections()
         self.nodes = {}
         self.control_flow_machine = ControlFlowMachine(self)

griptape_nodes/exe_types/node_types.py

@@ -17,6 +17,7 @@ from griptape_nodes.exe_types.core_types import (
     ParameterDictionary,
     ParameterGroup,
     ParameterList,
+    ParameterMessage,
     ParameterMode,
     ParameterTypeBuiltin,
 )
@@ -204,6 +205,11 @@ class BaseNode(ABC):
         # Default behavior is to do nothing, and indicate no other modified Parameters.
         return None  # noqa: RET501
 
+    def after_settings_changed(self, modified_parameters_set: set[str]) -> None:  # noqa: ARG002
+        """Callback for when the settings of this Node are changed."""
+        # Waiting for https://github.com/griptape-ai/griptape-nodes/issues/1309
+        return
+
     def on_griptape_event(self, event: BaseEvent) -> None:  # noqa: ARG002
         """Callback for when a Griptape Event comes destined for this Node."""
         return
@@ -265,6 +271,34 @@ class BaseNode(ABC):
             if parameter is not None:
                 parameter._ui_options["hide"] = not visible
 
+    def get_message_by_name_or_element_id(self, element: str) -> ParameterMessage | None:
+        element_items = self.root_ui_element.find_elements_by_type(ParameterMessage)
+        for element_item in element_items:
+            if element in (element_item.name, element_item.element_id):
+                return element_item
+        return None
+
+    def _set_message_visibility(self, names: str | list[str], *, visible: bool) -> None:
+        """Sets the visibility of one or more messages.
+
+        Args:
+            names (str or list of str): The message name(s) to update.
+            visible (bool): Whether to show (True) or hide (False) the messages.
+        """
+        if isinstance(names, str):
+            names = [names]
+
+        for name in names:
+            message = self.get_message_by_name_or_element_id(name)
+            if message is not None:
+                message.ui_options["hide"] = not visible
+
+    def hide_message_by_name(self, names: str | list[str]) -> None:
+        self._set_message_visibility(names, visible=False)
+
+    def show_message_by_name(self, names: str | list[str]) -> None:
+        self._set_message_visibility(names, visible=True)
+
     def hide_parameter_by_name(self, names: str | list[str]) -> None:
         """Hides one or more parameters by name."""
         self._set_parameter_visibility(names, visible=False)

griptape_nodes/machines/node_resolution.py

@@ -13,6 +13,7 @@ from griptape_nodes.exe_types.core_types import ParameterTypeBuiltin
 from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.machines.fsm import FSM, State
+from griptape_nodes.node_library.library_registry import LibraryRegistry
 from griptape_nodes.retained_mode.events.base_events import (
     ExecutionEvent,
     ExecutionGriptapeNodeEvent,
@@ -216,7 +217,7 @@ class ExecuteNodeState(State):
                             modified_parameter = current_node.get_parameter_by_name(modified_parameter_name)
                             if modified_parameter is not None:
                                 modified_request = AlterParameterEvent.create(
-                                    node_name=current_node.name, parameter=modified_parameter
+                                    node=current_node, parameter=modified_parameter
                                 )
                                 EventBus.publish_event(
                                     ExecutionGriptapeNodeEvent(ExecutionEvent(payload=modified_request))
@@ -339,12 +340,19 @@ class ExecuteNodeState(State):
                 )
 
         # Output values should already be saved!
+        library = LibraryRegistry.get_libraries_with_node_type(current_node.__class__.__name__)
+        if len(library) == 1:
+            library_name = library[0]
+        else:
+            library_name = None
         EventBus.publish_event(
             ExecutionGriptapeNodeEvent(
                 wrapped_event=ExecutionEvent(
                     payload=NodeResolvedEvent(
                         node_name=current_node.name,
                         parameter_output_values=TypeValidator.safe_serialize(current_node.parameter_output_values),
+                        node_type=current_node.__class__.__name__,
+                        specific_library_name=library_name,
                     )
                 )
             )

griptape_nodes/node_library/library_registry.py

@@ -84,6 +84,8 @@ class LibrarySchema(BaseModel):
     library itself.
     """
 
+    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.1.0"
+
     name: str
     library_schema_version: str
     metadata: LibraryMetadata

griptape_nodes/retained_mode/events/execution_events.py

@@ -230,6 +230,8 @@ class ControlFlowCancelledEvent(ExecutionPayload):
 class NodeResolvedEvent(ExecutionPayload):
     node_name: str
     parameter_output_values: dict
+    node_type: str
+    specific_library_name: str | None = None
 
 
 @dataclass

griptape_nodes/retained_mode/events/generate_request_payload_schemas.py

@@ -26,5 +26,5 @@ for payload_class_name, payload_class in payload_dict.items():
     else:
         logger.info("Skipping %s as it is not a RequestPayload.", payload_class_name)
 
-with Path("request_payload_schemas.json").open("w+") as file:
+with Path("request_payload_schemas.json").open("w+", encoding="utf-8") as file:
     file.write(json.dumps(list(payload_type_to_schema.values()), indent=2))