griptape-nodes 0.63.10__py3-none-any.whl → 0.64.1__py3-none-any.whl

griptape_nodes/retained_mode/managers/version_compatibility_manager.py

@@ -4,7 +4,7 @@ import importlib
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import TYPE_CHECKING, NamedTuple
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 import semver
 
@@ -35,8 +35,13 @@ from griptape_nodes.retained_mode.managers.fitness_problems.workflows.node_type_
 from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 
 if TYPE_CHECKING:
+    from griptape_nodes.exe_types.node_types import BaseNode
     from griptape_nodes.node_library.library_registry import LibrarySchema
     from griptape_nodes.node_library.workflow_registry import WorkflowMetadata
+    from griptape_nodes.retained_mode.events.parameter_events import (
+        SetParameterValueResultFailure,
+        SetParameterValueResultSuccess,
+    )
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
     from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
     from griptape_nodes.retained_mode.managers.fitness_problems.workflows.workflow_problem import WorkflowProblem
@@ -83,6 +88,38 @@ class WorkflowVersionCompatibilityCheck(ABC):
         """Perform the workflow compatibility check."""
 
 
+class SetParameterVersionCompatibilityCheck(ABC):
+    """Abstract base class for runtime parameter set version compatibility checks."""
+
+    @abstractmethod
+    def applies_to_set_parameter(self, node: BaseNode, parameter_name: str, value: Any) -> bool:
+        """Return True if this check applies to the given parameter set operation.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            value: The value being set
+
+        Returns:
+            True if this check should be performed for this parameter
+        """
+
+    @abstractmethod
+    def set_parameter_value(
+        self, node: BaseNode, parameter_name: str, value: Any
+    ) -> SetParameterValueResultSuccess | SetParameterValueResultFailure:
+        """Handle setting the parameter value with version compatibility logic.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            value: The value being set
+
+        Returns:
+            SetParameterValueResultSuccess or SetParameterValueResultFailure
+        """
+
+
 class VersionCompatibilityManager:
     """Manages version compatibility checks for libraries and other components."""
 
@@ -90,89 +127,74 @@ class VersionCompatibilityManager:
         self._event_manager = event_manager
         self._compatibility_checks: list[LibraryVersionCompatibilityCheck] = []
         self._workflow_compatibility_checks: list[WorkflowVersionCompatibilityCheck] = []
+        self._set_parameter_compatibility_checks: list[SetParameterVersionCompatibilityCheck] = []
         self._discover_version_checks()
 
     def _discover_version_checks(self) -> None:
-        """Automatically discover and register library and workflow version compatibility checks."""
-        self._discover_library_version_checks()
-        self._discover_workflow_version_checks()
+        """Automatically discover and register all version compatibility checks from the versions/ directory."""
+        try:
+            import griptape_nodes.version_compatibility.versions as versions_module
 
-    def _discover_library_version_checks(self) -> None:
-        """Discover and register library version compatibility checks."""
-        # Get the path to the version_compatibility/versions directory
-        import griptape_nodes.version_compatibility.versions as versions_module
+            if versions_module.__file__ is None:
+                logger.debug("No version compatibility checks directory found, skipping discovery")
+                return
 
-        versions_path = Path(versions_module.__file__).parent
+            versions_path = Path(versions_module.__file__).parent
 
-        # Iterate through version directories
-        for version_dir in versions_path.iterdir():
-            if version_dir.is_dir() and not version_dir.name.startswith("__"):
-                self._discover_checks_in_version_dir(version_dir)
+            # Iterate through version directories (e.g., v0_39_0, v0_63_8)
+            for version_dir in versions_path.iterdir():
+                if not version_dir.is_dir() or version_dir.name.startswith("__"):
+                    continue
 
-    def _discover_workflow_version_checks(self) -> None:
-        """Discover and register workflow version compatibility checks."""
-        try:
-            import griptape_nodes.version_compatibility.workflow_versions as workflow_versions_module
+                # Iterate through Python files in the version directory
+                for check_file in version_dir.glob("*.py"):
+                    if check_file.name.startswith("__"):
+                        continue
+
+                    # Import the module once
+                    file_module_path = (
+                        f"griptape_nodes.version_compatibility.versions.{version_dir.name}.{check_file.stem}"
+                    )
+                    try:
+                        check_module = importlib.import_module(file_module_path)
+                    except ImportError as e:
+                        logger.debug("Failed to import check module %s: %s", file_module_path, e)
+                        continue
 
-            workflow_versions_path = Path(workflow_versions_module.__file__).parent
+                    # Scan and register all check types in this module
+                    self._register_checks_from_module(check_module)
 
-            # Iterate through version directories
-            for version_dir in workflow_versions_path.iterdir():
-                if version_dir.is_dir() and not version_dir.name.startswith("__"):
-                    self._discover_workflow_checks_in_version_dir(version_dir)
         except ImportError:
-            # workflow_versions directory doesn't exist yet, skip discovery
-            logger.debug("No workflow version compatibility checks directory found, skipping workflow check discovery")
-
-    def _discover_checks_in_version_dir(self, version_dir: Path) -> None:
-        """Discover compatibility checks in a specific version directory."""
-        # Iterate through Python files in the version directory
-        for check_file in version_dir.glob("*.py"):
-            if check_file.name.startswith("__"):
-                continue
+            logger.debug("No version compatibility checks directory found, skipping discovery")
+
+    def _register_checks_from_module(self, check_module: Any) -> None:
+        """Register all version compatibility checks found in a module.
 
-            # Import the module
-            module_path = f"griptape_nodes.version_compatibility.versions.{version_dir.name}.{check_file.stem}"
-            module = importlib.import_module(module_path)
-
-            # Look for classes that inherit from LibraryVersionCompatibilityCheck
-            for attr_name in dir(module):
-                attr = getattr(module, attr_name)
-                if (
-                    isinstance(attr, type)
-                    and issubclass(attr, LibraryVersionCompatibilityCheck)
-                    and attr is not LibraryVersionCompatibilityCheck
-                ):
-                    check_instance = attr()
-                    self._compatibility_checks.append(check_instance)
-                    logger.debug("Registered library version compatibility check: %s", attr_name)
-
-    def _discover_workflow_checks_in_version_dir(self, version_dir: Path) -> None:
-        """Discover workflow compatibility checks in a specific version directory."""
-        # Iterate through Python files in the version directory
-        for check_file in version_dir.glob("*.py"):
-            if check_file.name.startswith("__"):
+        Args:
+            check_module: The imported module to scan for check classes
+        """
+        for attr_name in dir(check_module):
+            attr = getattr(check_module, attr_name)
+            if not isinstance(attr, type):
                 continue
 
-            # Import the module
-            module_path = f"griptape_nodes.version_compatibility.workflow_versions.{version_dir.name}.{check_file.stem}"
-            try:
-                module = importlib.import_module(module_path)
-            except ImportError as e:
-                logger.debug("Failed to import workflow compatibility check module %s: %s", module_path, e)
+            # Skip abstract base classes
+            if ABC in getattr(attr, "__bases__", ()):
                 continue
 
-            # Look for classes that inherit from WorkflowVersionCompatibilityCheck
-            for attr_name in dir(module):
-                attr = getattr(module, attr_name)
-                if (
-                    isinstance(attr, type)
-                    and issubclass(attr, WorkflowVersionCompatibilityCheck)
-                    and attr is not WorkflowVersionCompatibilityCheck
-                ):
-                    check_instance = attr()
-                    self._workflow_compatibility_checks.append(check_instance)
-                    logger.debug("Registered workflow version compatibility check: %s", attr_name)
+            # Register based on which base class it inherits from
+            if issubclass(attr, LibraryVersionCompatibilityCheck):
+                check_instance = attr()
+                self._compatibility_checks.append(check_instance)
+                logger.debug("Registered library version compatibility check: %s", attr_name)
+            elif issubclass(attr, WorkflowVersionCompatibilityCheck):
+                check_instance = attr()
+                self._workflow_compatibility_checks.append(check_instance)
+                logger.debug("Registered workflow version compatibility check: %s", attr_name)
+            elif issubclass(attr, SetParameterVersionCompatibilityCheck):
+                check_instance = attr()
+                self._set_parameter_compatibility_checks.append(check_instance)
+                logger.debug("Registered set parameter version compatibility check: %s", attr_name)
 
     def _check_library_for_deprecated_nodes(
         self, library_data: LibrarySchema
@@ -333,6 +355,28 @@ class VersionCompatibilityManager:
 
         return issues
 
+    def check_set_parameter_version_compatibility(
+        self, node: BaseNode, parameter_name: str, value: Any
+    ) -> SetParameterValueResultSuccess | SetParameterValueResultFailure | None:
+        """Check if a parameter set operation requires version compatibility handling.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            value: The value being set
+
+        Returns:
+            SetParameterValueResultSuccess, SetParameterValueResultFailure, or None if no check applies
+        """
+        # Iterate through registered checks and find the first one that applies
+        for check_instance in self._set_parameter_compatibility_checks:
+            if check_instance.applies_to_set_parameter(node, parameter_name, value):
+                # First matching check handles the parameter
+                return check_instance.set_parameter_value(node, parameter_name, value)
+
+        # No checks applied
+        return None
+
     def _get_current_engine_version(self) -> semver.VersionInfo:
         """Get the current engine version."""
         result = GriptapeNodes.handle_request(GetEngineVersionRequest())

griptape_nodes/retained_mode/managers/workflow_manager.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, NamedTuple, TypeVar, cast
 
 import aiofiles
+import portalocker
 import semver
 import tomlkit
 from rich.box import HEAVY_EDGE
@@ -1269,9 +1270,12 @@ class WorkflowManager:
         success: bool
         error_details: str
 
-    async def _write_workflow_file(self, file_path: Path, content: str, file_name: str) -> WriteWorkflowFileResult:
+    def _write_workflow_file(self, file_path: Path, content: str, file_name: str) -> WriteWorkflowFileResult:
         """Write workflow content to file with proper validation and error handling.
 
+        Uses portalocker for exclusive file locking to prevent concurrent writes.
+        First write wins - if another process is writing, this call fails immediately.
+
         Args:
             file_path: Path where to write the file
             content: Content to write
@@ -1295,13 +1299,34 @@ class WorkflowManager:
             details = f"Attempted to save workflow '{file_name}'. Failed when creating directory structure: {e}"
             return self.WriteWorkflowFileResult(success=False, error_details=details)
 
-        # Write the file content
+        # Write the file content with exclusive lock (non-blocking)
+        error_details = None
         try:
-            async with aiofiles.open(file_path, "w", encoding="utf-8") as file:
-                await file.write(content)
+            with portalocker.Lock(
+                file_path,
+                mode="w",
+                encoding="utf-8",
+                timeout=0,  # Non-blocking: fail immediately if locked
+                flags=portalocker.LockFlags.EXCLUSIVE,
+            ) as fh:
+                fh.write(content)
+        except portalocker.LockException:
+            error_details = (
+                f"Attempted to save workflow '{file_name}'. Another process is currently writing to this workflow file"
+            )
+        except PermissionError as e:
+            error_details = f"Attempted to save workflow '{file_name}'. Permission denied: {e}"
+        except IsADirectoryError:
+            error_details = f"Attempted to save workflow '{file_name}'. Path is a directory, not a file"
+        except UnicodeEncodeError as e:
+            error_details = f"Attempted to save workflow '{file_name}'. Content encoding error: {e}"
         except OSError as e:
-            details = f"Attempted to save workflow '{file_name}'. Failed when writing file content: {e}"
-            return self.WriteWorkflowFileResult(success=False, error_details=details)
+            error_details = f"Attempted to save workflow '{file_name}'. OS error: {e}"
+        except Exception as e:
+            error_details = f"Attempted to save workflow '{file_name}'. Unexpected error: {type(e).__name__}: {e}"
+
+        if error_details:
+            return self.WriteWorkflowFileResult(success=False, error_details=error_details)
 
         return self.WriteWorkflowFileResult(success=True, error_details="")
 
@@ -1546,7 +1571,10 @@ class WorkflowManager:
             return SaveWorkflowFileFromSerializedFlowResultFailure(result_details=details)
 
         # Write the workflow file
-        write_result = await self._write_workflow_file(file_path, final_code_output, request.file_name)
+        # TODO: https://github.com/griptape-ai/griptape-nodes/issues/3169
+        # This is a synchronous call within an async context and may block the event loop.
+        # Consider using asyncio.to_thread() to run in a thread pool for better async performance.
+        write_result = self._write_workflow_file(file_path, final_code_output, request.file_name)
         if not write_result.success:
             return SaveWorkflowFileFromSerializedFlowResultFailure(result_details=write_result.error_details)
 
@@ -2901,6 +2929,7 @@ class WorkflowManager:
         import_recorder.add_from_import("griptape_nodes.node_library.library_registry", "NodeDeprecationMetadata")
         import_recorder.add_from_import("griptape_nodes.node_library.library_registry", "IconVariant")
         import_recorder.add_from_import("griptape_nodes.retained_mode.events.node_events", "CreateNodeRequest")
+        import_recorder.add_from_import("griptape_nodes.retained_mode.events.node_events", "CreateNodeGroupRequest")
         import_recorder.add_from_import(
             "griptape_nodes.retained_mode.events.parameter_events", "AddParameterToNodeRequest"
         )
@@ -2925,7 +2954,8 @@ class WorkflowManager:
                     create_node_request_args.append(
                         ast.keyword(arg=field.name, value=ast.Constant(value=field_value, lineno=1, col_offset=0))
                     )
-
+        # Get the actual request class name (CreateNodeRequest or CreateNodeGroupRequest)
+        request_class_name = type(create_node_request).__name__
         # Handle the create node command and assign to node name
         create_node_call_ast = ast.Assign(
             targets=[ast.Name(id=node_variable_name, ctx=ast.Store(), lineno=1, col_offset=0)],
@@ -2940,7 +2970,7 @@ class WorkflowManager:
                     ),
                     args=[
                         ast.Call(
-                            func=ast.Name(id="CreateNodeRequest", ctx=ast.Load(), lineno=1, col_offset=0),
+                            func=ast.Name(id=request_class_name, ctx=ast.Load(), lineno=1, col_offset=0),
                             args=[],
                             keywords=create_node_request_args,
                             lineno=1,
@@ -2951,7 +2981,7 @@ class WorkflowManager:
                     lineno=1,
                     col_offset=0,
                 ),
-                attr="node_name",
+                attr="node_name" if request_class_name == "CreateNodeRequest" else "node_group_name",
                 ctx=ast.Load(),
                 lineno=1,
                 col_offset=0,
@@ -3004,6 +3034,11 @@ class WorkflowManager:
 
             # Generate handle_request calls for element_modification_commands
             for element_command in serialized_node_command.element_modification_commands:
+                # Add import for this element command type
+                element_command_class_name = element_command.__class__.__name__
+                element_command_module = element_command.__class__.__module__
+                import_recorder.add_from_import(element_command_module, element_command_class_name)
+
                 # Strip default values from element_command
                 element_command_args = []
                 if is_dataclass(element_command):

griptape_nodes/servers/mcp.py

@@ -23,23 +23,49 @@ from griptape_nodes.retained_mode.events.connection_events import (
     DeleteConnectionRequest,
     ListConnectionsForNodeRequest,
 )
+from griptape_nodes.retained_mode.events.execution_events import (
+    ResolveNodeRequest,
+    StartFlowFromNodeRequest,
+    StartFlowRequest,
+)
 from griptape_nodes.retained_mode.events.flow_events import ListNodesInFlowRequest
+from griptape_nodes.retained_mode.events.library_events import (
+    ListCategoriesInLibraryRequest,
+    ListNodeTypesInLibraryRequest,
+    ListRegisteredLibrariesRequest,
+)
 from griptape_nodes.retained_mode.events.node_events import (
     CreateNodeRequest,
     DeleteNodeRequest,
     GetNodeMetadataRequest,
     GetNodeResolutionStateRequest,
     ListParametersOnNodeRequest,
+    ResetNodeToDefaultsRequest,
+    SetLockNodeStateRequest,
     SetNodeMetadataRequest,
 )
+from griptape_nodes.retained_mode.events.object_events import RenameObjectRequest
 from griptape_nodes.retained_mode.events.parameter_events import (
+    GetConnectionsForParameterRequest,
+    GetParameterDetailsRequest,
     GetParameterValueRequest,
     SetParameterValueRequest,
 )
+from griptape_nodes.retained_mode.events.workflow_events import RunWorkflowWithCurrentStateRequest
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
 from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
 
 SUPPORTED_REQUEST_EVENTS: dict[str, type[RequestPayload]] = {
+    # Workflows
+    "RunWorkflowWithCurrentStateRequest": RunWorkflowWithCurrentStateRequest,
+    # Libraries
+    "ListRegisteredLibrariesRequest": ListRegisteredLibrariesRequest,
+    "ListNodeTypesInLibraryRequest": ListNodeTypesInLibraryRequest,
+    "ListCategoriesInLibraryRequest": ListCategoriesInLibraryRequest,
+    # Execution
+    "ResolveNodeRequest": ResolveNodeRequest,
+    "StartFlowRequest": StartFlowRequest,
+    "StartFlowFromNodeRequest": StartFlowFromNodeRequest,
     # Nodes
     "CreateNodeRequest": CreateNodeRequest,
     "DeleteNodeRequest": DeleteNodeRequest,
@@ -47,6 +73,10 @@ SUPPORTED_REQUEST_EVENTS: dict[str, type[RequestPayload]] = {
     "GetNodeResolutionStateRequest": GetNodeResolutionStateRequest,
     "GetNodeMetadataRequest": GetNodeMetadataRequest,
     "SetNodeMetadataRequest": SetNodeMetadataRequest,
+    "ResetNodeToDefaultsRequest": ResetNodeToDefaultsRequest,
+    "SetLockNodeStateRequest": SetLockNodeStateRequest,
+    # Objects
+    "RenameObjectRequest": RenameObjectRequest,
     # Connections
     "CreateConnectionRequest": CreateConnectionRequest,
     "DeleteConnectionRequest": DeleteConnectionRequest,
@@ -55,6 +85,8 @@ SUPPORTED_REQUEST_EVENTS: dict[str, type[RequestPayload]] = {
     "ListParametersOnNodeRequest": ListParametersOnNodeRequest,
     "GetParameterValueRequest": GetParameterValueRequest,
     "SetParameterValueRequest": SetParameterValueRequest,
+    "GetParameterDetailsRequest": GetParameterDetailsRequest,
+    "GetConnectionsForParameterRequest": GetConnectionsForParameterRequest,
 }
 
 GTN_MCP_SERVER_HOST = os.getenv("GTN_MCP_SERVER_HOST", "localhost")

griptape_nodes/version_compatibility/versions/v0_63_8/__init__.py

@@ -0,0 +1 @@
+"""Version 0.63.8 parameter compatibility checks."""

griptape_nodes/version_compatibility/versions/v0_63_8/deprecated_nodegroup_parameters.py

@@ -0,0 +1,105 @@
+"""Check for deprecated job_group and execution_environment parameters."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, ClassVar
+
+import semver
+
+from griptape_nodes.exe_types.node_types import NodeGroupNode
+from griptape_nodes.retained_mode.events.app_events import (
+    GetEngineVersionRequest,
+    GetEngineVersionResultSuccess,
+)
+from griptape_nodes.retained_mode.events.parameter_events import SetParameterValueResultSuccess
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
+    SetParameterVersionCompatibilityCheck,
+)
+
+if TYPE_CHECKING:
+    from griptape_nodes.exe_types.node_types import BaseNode
+
+logger = logging.getLogger("griptape_nodes")
+
+
+class DeprecatedNodeGroupParametersCheck(SetParameterVersionCompatibilityCheck):
+    """Check for deprecated job_group and execution_environment parameters.
+
+    These parameters were removed in engine version 0.63.8 for all nodes except NodeGroup.
+    This check intercepts attempts to set these parameters and logs a warning prompting
+    users to resave their workflows.
+    """
+
+    DEPRECATED_PARAMETERS: ClassVar[set[str]] = {"job_group", "execution_environment"}
+    REMOVAL_VERSION: ClassVar[semver.VersionInfo] = semver.VersionInfo(0, 63, 8)
+
+    def __init__(self) -> None:
+        """Initialize the check with an empty set of warned workflows."""
+        super().__init__()
+        self._warned_workflows: set[str] = set()
+
+    def applies_to_set_parameter(self, node: BaseNode, parameter_name: str, _value: Any) -> bool:
+        """Return True if this is a deprecated parameter on a non-NodeGroup node.
+
+        Args:
+            node: The node instance
+            parameter_name: Name of the parameter being set
+            _value: The value being set (unused)
+
+        Returns:
+            True if this check should handle this parameter
+        """
+        # Check parameter name first (fastest check)
+        if parameter_name not in self.DEPRECATED_PARAMETERS:
+            return False
+
+        # Check if node is NOT a NodeGroup (we only block for non-NodeGroup nodes)
+        if isinstance(node, NodeGroupNode):
+            return False
+
+        # Check if current engine version is >= 0.63.8
+        engine_version_result = GriptapeNodes.handle_request(GetEngineVersionRequest())
+        if not isinstance(engine_version_result, GetEngineVersionResultSuccess):
+            return False
+
+        current_version = semver.VersionInfo(
+            engine_version_result.major, engine_version_result.minor, engine_version_result.patch
+        )
+        return current_version >= self.REMOVAL_VERSION
+
+    def set_parameter_value(self, _node: BaseNode, parameter_name: str, _value: Any) -> SetParameterValueResultSuccess:
+        """Handle the deprecated parameter by logging a warning and returning success with empty value.
+
+        Args:
+            _node: The node instance (unused)
+            parameter_name: Name of the parameter being set
+            _value: The value being set (unused)
+
+        Returns:
+            SetParameterValueResultSuccess with empty list value
+        """
+        # Get the current workflow name to track warnings per workflow
+        workflow_name = GriptapeNodes.ContextManager().get_current_workflow_name()
+
+        # Check if we've already warned for this workflow
+        if workflow_name not in self._warned_workflows:
+            # Mark this workflow as warned
+            self._warned_workflows.add(workflow_name)
+
+            # Log warning with all deprecated parameters
+            deprecated_params_list = ", ".join(f"'{param}'" for param in self.DEPRECATED_PARAMETERS)
+            logger.warning(
+                "This workflow uses deprecated parameters (%s) that were removed in engine version %s. "
+                "Please resave your workflow and this warning will go away.",
+                deprecated_params_list,
+                self.REMOVAL_VERSION,
+            )
+
+        # Return success with None as the value (parameter doesn't exist, so no meaningful value to return)
+        return SetParameterValueResultSuccess(
+            finalized_value=None,
+            data_type="any",
+            result_details=f"Parameter '{parameter_name}' was removed in v{self.REMOVAL_VERSION}. Please resave this workflow.",
+        )

{griptape_nodes-0.63.10.dist-info → griptape_nodes-0.64.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.63.10
+Version: 0.64.1
 Summary: Add your description here
 Requires-Dist: griptape>=1.8.12
 Requires-Dist: pydantic>=2.10.6
@@ -27,6 +27,7 @@ Requires-Dist: aiofiles>=25.1.0
 Requires-Dist: aioshutil>=1.5
 Requires-Dist: ruamel-yaml>=0.18.15
 Requires-Dist: asyncio-thread-runner>=1.0
+Requires-Dist: portalocker>=2.10.0
 Requires-Dist: austin-dist>=3.7.0 ; extra == 'profiling'
 Requires-Python: >=3.12.0, <3.13
 Provides-Extra: profiling
@@ -55,6 +56,7 @@ This repository contains the Griptape Nodes Engine - the local component that ru
 - **📚 Full Documentation:** [docs.griptapenodes.com](https://docs.griptapenodes.com)
 - **⚙️ Installation:** [docs.griptapenodes.com/en/stable/installation/](https://docs.griptapenodes.com/en/latest/installation/)
 - **🔧 Engine Configuration:** [docs.griptapenodes.com/en/stable/configuration/](https://docs.griptapenodes.com/en/latest/configuration/)
+- **📋 Migration Guide:** [MIGRATION.md](MIGRATION.md) - Guide for migrating from deprecated nodes
 
 **🧩 Extending Griptape Nodes:**