griptape-nodes 0.71.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

griptape_nodes/drivers/storage/griptape_cloud_storage_driver.py

@@ -1,12 +1,15 @@
 import logging
 import os
+from collections.abc import Callable
 from pathlib import Path
-from urllib.parse import urljoin
+from typing import Any
+from urllib.parse import urljoin, urlparse
 
 import httpx
 
 from griptape_nodes.drivers.storage.base_storage_driver import BaseStorageDriver, CreateSignedUploadUrlResponse
 from griptape_nodes.retained_mode.events.os_events import ExistingFilePolicy
+from griptape_nodes.utils.path_utils import get_workspace_relative_path
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -42,22 +45,24 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
     def create_signed_upload_url(
         self, path: Path, existing_file_policy: ExistingFilePolicy = ExistingFilePolicy.OVERWRITE
     ) -> CreateSignedUploadUrlResponse:
+        normalized_path = get_workspace_relative_path(path, self.workspace_directory)
+
         if existing_file_policy != ExistingFilePolicy.OVERWRITE:
             logger.warning(
                 "Griptape Cloud storage only supports OVERWRITE policy. "
                 "Requested policy '%s' will be ignored for file: %s",
                 existing_file_policy.value,
-                path,
+                normalized_path,
             )
 
-        self._create_asset(path.as_posix())
+        self._create_asset(normalized_path.as_posix())
 
-        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{path.as_posix()}")
+        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{normalized_path.as_posix()}")
         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 upload URL for file {path}: {e}"
+            msg = f"Failed to create presigned upload URL for file {normalized_path}: {e}"
             logger.error(msg)
             raise RuntimeError(msg) from e
 
@@ -67,16 +72,77 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
             "url": response_data["url"],
             "headers": response_data.get("headers", {}),
             "method": "PUT",
-            "file_path": str(path),
+            "file_path": str(normalized_path),
         }
 
+    def _parse_cloud_asset_path(self, path: str | Path) -> Path:
+        """Parse cloud asset URL path to extract workspace-relative portion.
+
+        Handles multiple input formats:
+        - Full URLs: https://cloud.griptape.ai/buckets/{id}/assets/{path}
+        - Path-only: /buckets/{id}/assets/{path}
+        - Workspace-relative: {path}
+
+        When a full URL is provided, validates that the domain matches
+        self.base_url to prevent cross-environment URL mixing.
+
+        Args:
+            path: String or Path object that may contain a cloud asset URL pattern
+
+        Returns:
+            Workspace-relative path
+
+        Raises:
+            ValueError: When full URL domain doesn't match configured base_url
+        """
+        # Convert to string for processing
+        path_str = str(path) if isinstance(path, Path) else path
+
+        # Validate domain for full URLs (only if it contains :// scheme separator)
+        if "://" in path_str and path_str.startswith(("http://", "https://")):
+            input_parsed = urlparse(path_str)
+            input_domain = input_parsed.netloc.lower()
+
+            base_parsed = urlparse(self.base_url)
+            expected_domain = base_parsed.netloc.lower()
+
+            if input_domain != expected_domain:
+                msg = (
+                    f"Invalid cloud asset URL: domain '{input_domain}' does not match "
+                    f"configured base URL '{self.base_url}'. "
+                    f"Expected domain: '{expected_domain}'"
+                )
+                logger.error(msg)
+                raise ValueError(msg)
+
+            # Extract path component for further processing
+            path_str = input_parsed.path.lstrip("/")
+
+        # Check if it's a cloud asset URL pattern
+        # Handle both /buckets/ and buckets/ (after leading slash removal)
+        has_buckets = "/buckets/" in path_str or path_str.startswith("buckets/")
+        has_assets = "/assets/" in path_str
+        if has_buckets and has_assets:
+            # Extract workspace-relative path from cloud URL
+            # Format: /buckets/{bucket_id}/assets/{workspace_relative_path} or buckets/{bucket_id}/assets/{workspace_relative_path}
+            parts = path_str.split("/assets/", 1)
+            expected_parts_count = 2
+            if len(parts) == expected_parts_count:
+                return Path(parts[1])  # Return the workspace-relative path after /assets/
+
+        # For non-cloud paths, return as-is
+        return Path(path_str)
+
     def create_signed_download_url(self, path: Path) -> str:
-        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{path.as_posix()}")
+        # Parse cloud asset URLs before normalizing
+        parsed_path = self._parse_cloud_asset_path(path)
+        normalized_path = get_workspace_relative_path(parsed_path, self.workspace_directory)
+        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{normalized_path.as_posix()}")
         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 download URL for file {path}: {e}"
+            msg = f"Failed to create presigned download URL for file {normalized_path}: {e}"
             logger.error(msg)
             raise RuntimeError(msg) from e
 
@@ -84,6 +150,51 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
 
         return response_data["url"]
 
+    def save_file(
+        self, path: Path, file_content: bytes, existing_file_policy: ExistingFilePolicy = ExistingFilePolicy.OVERWRITE
+    ) -> str:
+        """Save a file to cloud storage via HTTP upload.
+
+        Args:
+            path: The path of the file to save.
+            file_content: The file content as bytes.
+            existing_file_policy: How to handle existing files. Defaults to OVERWRITE.
+
+        Returns:
+            The full asset URL for the saved file.
+
+        Raises:
+            RuntimeError: If file upload fails.
+        """
+        normalized_path = get_workspace_relative_path(path, self.workspace_directory)
+
+        if existing_file_policy != ExistingFilePolicy.OVERWRITE:
+            logger.warning(
+                "GriptapeCloudStorageDriver only supports OVERWRITE policy, got %s. "
+                "The file will be overwritten if it exists.",
+                existing_file_policy,
+            )
+
+        # Get signed upload URL
+        upload_response = self.create_signed_upload_url(path, existing_file_policy)
+
+        # Upload the file using the signed URL
+        try:
+            response = httpx.request(
+                upload_response["method"],
+                upload_response["url"],
+                content=file_content,
+                headers=upload_response["headers"],
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to upload file {normalized_path}: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        # Return the full asset URL
+        return urljoin(self.base_url, f"/buckets/{self.bucket_id}/assets/{normalized_path.as_posix()}")
+
     def _create_asset(self, asset_name: str) -> str:
         url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/assets")
         try:
@@ -160,6 +271,22 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
 
         return file_names
 
+    def get_asset_url(self, path: Path) -> str:
+        """Get the permanent unsigned URL for a cloud asset.
+
+        Returns the permanent public URL for the asset (not the presigned URL).
+
+        Args:
+            path: The path of the file
+
+        Returns:
+            Permanent cloud asset URL
+        """
+        # Parse cloud asset URLs before normalizing
+        parsed_path = self._parse_cloud_asset_path(path)
+        normalized_path = get_workspace_relative_path(parsed_path, self.workspace_directory)
+        return urljoin(self.base_url, f"/buckets/{self.bucket_id}/assets/{normalized_path.as_posix()}")
+
     @staticmethod
     def list_buckets(*, base_url: str, api_key: str) -> list[dict]:
         """List all buckets in Griptape Cloud.
@@ -190,12 +317,259 @@ class GriptapeCloudStorageDriver(BaseStorageDriver):
         Args:
             path: The path of the file to delete.
         """
-        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/assets/{path.as_posix()}")
+        normalized_path = get_workspace_relative_path(path, self.workspace_directory)
+        url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/assets/{normalized_path.as_posix()}")
 
         try:
             response = httpx.delete(url, headers=self.headers)
             response.raise_for_status()
         except httpx.HTTPStatusError as e:
-            msg = f"Failed to delete file {path}: {e}"
+            msg = f"Failed to delete file {normalized_path}: {e}"
             logger.error(msg)
             raise RuntimeError(msg) from e
+
+    def _is_cloud_asset_url(self, url_str: str) -> bool:
+        """Check if URL is a Griptape Cloud asset URL with domain validation.
+
+        Detects URLs matching pattern: https://cloud.griptape.ai/buckets/{id}/assets/{path}
+        Validates domain matches expected cloud domain.
+
+        Args:
+            url_str: String to check
+
+        Returns:
+            True if url_str is a valid cloud asset URL
+        """
+        # Fast negative checks first
+        if not url_str:
+            return False
+
+        # Must be a full URL with scheme
+        if not url_str.startswith(("http://", "https://")):
+            return False
+
+        # Parse URL to check domain
+        parsed = urlparse(url_str)
+        domain = parsed.netloc.lower()
+
+        # Get expected cloud domain from instance
+        expected_parsed = urlparse(self.base_url)
+        expected_domain = expected_parsed.netloc.lower()
+
+        # Domain must match
+        if domain != expected_domain:
+            return False
+
+        # Must contain both /buckets/ and /assets/ patterns
+        path = parsed.path
+        has_buckets = "/buckets/" in path
+        has_assets = "/assets/" in path
+
+        # Success path - valid cloud asset URL
+        return has_buckets and has_assets
+
+    def _extract_workspace_path_from_cloud_url(self, url_str: str) -> str | None:
+        """Extract workspace-relative path from cloud asset URL.
+
+        Parses URLs like: /buckets/{bucket_id}/assets/{workspace_path}
+        Returns just the {workspace_path} portion.
+
+        Args:
+            url_str: Cloud asset URL
+
+        Returns:
+            Workspace-relative path, or None if parsing fails
+        """
+        parsed = urlparse(url_str)
+        path = parsed.path
+
+        # Extract workspace-relative path from: /buckets/{bucket_id}/assets/{workspace_path}
+        expected_parts = 2
+        try:
+            parts = path.split("/assets/", 1)
+            if len(parts) != expected_parts:
+                return None
+            return parts[1]
+        except Exception:
+            return None
+
+    def _create_signed_download_url_from_asset_url(self, asset_url: str) -> str | None:
+        """Create a signed download URL for a cloud asset.
+
+        Args:
+            asset_url: Cloud asset URL to convert
+
+        Returns:
+            Signed download URL if successful, None if fails
+        """
+        # Extract workspace-relative path
+        workspace_path = self._extract_workspace_path_from_cloud_url(asset_url)
+        if not workspace_path:
+            logger.debug("Could not extract workspace path from cloud URL: %s", asset_url)
+            return None
+
+        # Build API URL for signed download URL
+        api_url = urljoin(self.base_url, f"/api/buckets/{self.bucket_id}/asset-urls/{workspace_path}")
+
+        # Make API request to get signed URL
+        try:
+            response = httpx.post(api_url, json={"method": "GET"}, headers=self.headers)
+            response.raise_for_status()
+
+            response_data = response.json()
+            signed_url = response_data["url"]
+
+            logger.info("Converted cloud asset URL to signed URL: %s", asset_url)
+        except Exception as e:
+            if isinstance(e, httpx.HTTPStatusError):
+                logger.warning(
+                    "Failed to create signed download URL for %s: HTTP %s", asset_url, e.response.status_code
+                )
+            else:
+                logger.warning("Failed to create signed download URL for %s: %s", asset_url, e)
+            return None
+        else:
+            return signed_url
+
+    @staticmethod
+    def is_cloud_asset_url(url_str: str, base_url: str | None = None) -> bool:
+        """Check if URL is a Griptape Cloud asset URL with domain validation.
+
+        Static version for use without driver instance (e.g., httpx patching layer).
+        Detects URLs matching pattern: https://cloud.griptape.ai/buckets/{id}/assets/{path}
+        Validates domain matches expected cloud domain.
+
+        Args:
+            url_str: String to check
+            base_url: Expected cloud domain URL. If None, reads from GT_CLOUD_BASE_URL env var.
+
+        Returns:
+            True if url_str is a valid cloud asset URL
+        """
+        # Fast negative checks first
+        if not url_str:
+            return False
+
+        # Must be a full URL with scheme
+        if not url_str.startswith(("http://", "https://")):
+            return False
+
+        # Parse URL to check domain
+        parsed = urlparse(url_str)
+        domain = parsed.netloc.lower()
+
+        # Get expected cloud domain from parameter or environment
+        if base_url is None:
+            base_url = os.environ.get("GT_CLOUD_BASE_URL", "https://cloud.griptape.ai")
+
+        expected_parsed = urlparse(base_url)
+        expected_domain = expected_parsed.netloc.lower()
+
+        # Domain must match
+        if domain != expected_domain:
+            return False
+
+        # Must contain both /buckets/ and /assets/ patterns
+        path = parsed.path
+        has_buckets = "/buckets/" in path
+        has_assets = "/assets/" in path
+
+        # Success path - valid cloud asset URL
+        return has_buckets and has_assets
+
+    @staticmethod
+    def extract_workspace_path_from_cloud_url(url_str: str) -> str | None:
+        """Extract workspace-relative path from cloud asset URL.
+
+        Static version for use without driver instance.
+        Parses URLs like: /buckets/{bucket_id}/assets/{workspace_path}
+        Returns just the {workspace_path} portion.
+
+        Args:
+            url_str: Cloud asset URL
+
+        Returns:
+            Workspace-relative path, or None if parsing fails
+        """
+        parsed = urlparse(url_str)
+        path = parsed.path
+
+        # Extract workspace-relative path from: /buckets/{bucket_id}/assets/{workspace_path}
+        expected_parts = 2
+        try:
+            parts = path.split("/assets/", 1)
+            if len(parts) != expected_parts:
+                return None
+            return parts[1]
+        except Exception:
+            return None
+
+    @staticmethod
+    def create_signed_download_url_from_asset_url(
+        asset_url: str,
+        bucket_id: str | None = None,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        *,
+        httpx_request_func: Callable[..., Any],
+    ) -> str | None:
+        """Create a signed download URL for a cloud asset.
+
+        Static version for use without driver instance (e.g., httpx patching layer).
+
+        Args:
+            asset_url: Cloud asset URL to convert
+            bucket_id: Bucket ID. If None, reads from GT_CLOUD_BUCKET_ID env var.
+            api_key: API key. If None, reads from GT_CLOUD_API_KEY env var.
+            base_url: Cloud base URL. If None, reads from GT_CLOUD_BASE_URL env var.
+            httpx_request_func: The httpx request function to use (original, not patched)
+
+        Returns:
+            Signed download URL if successful, None if fails
+        """
+        # Get credentials from parameters or environment
+        if bucket_id is None:
+            bucket_id = os.environ.get("GT_CLOUD_BUCKET_ID")
+        if api_key is None:
+            api_key = os.environ.get("GT_CLOUD_API_KEY")
+        if base_url is None:
+            base_url = os.environ.get("GT_CLOUD_BASE_URL", "https://cloud.griptape.ai")
+
+        # Guard: Check for required credentials
+        if not bucket_id:
+            logger.debug("GT_CLOUD_BUCKET_ID not set, skipping cloud URL conversion: %s", asset_url)
+            return None
+
+        if not api_key:
+            logger.debug("GT_CLOUD_API_KEY not set, skipping cloud URL conversion: %s", asset_url)
+            return None
+
+        # Extract workspace-relative path
+        workspace_path = GriptapeCloudStorageDriver.extract_workspace_path_from_cloud_url(asset_url)
+        if not workspace_path:
+            logger.debug("Could not extract workspace path from cloud URL: %s", asset_url)
+            return None
+
+        # Build API URL for signed download URL
+        api_url = urljoin(base_url, f"/api/buckets/{bucket_id}/asset-urls/{workspace_path}")
+
+        # Make API request to get signed URL
+        try:
+            headers = {"Authorization": f"Bearer {api_key}"}
+            response = httpx_request_func("POST", api_url, json={"method": "GET"}, headers=headers)
+            response.raise_for_status()
+
+            response_data = response.json()
+            signed_url = response_data["url"]
+
+            logger.info("Converted cloud asset URL to signed URL: %s", asset_url)
+        except Exception as e:
+            if isinstance(e, httpx.HTTPStatusError):
+                logger.warning(
+                    "Failed to create signed download URL for %s: HTTP %s", asset_url, e.response.status_code
+                )
+            else:
+                logger.warning("Failed to create signed download URL for %s: %s", asset_url, e)
+            return None
+        else:
+            return signed_url

griptape_nodes/drivers/storage/local_storage_driver.py

@@ -6,8 +6,9 @@ from urllib.parse import urljoin
 import httpx
 
 from griptape_nodes.drivers.storage.base_storage_driver import BaseStorageDriver, CreateSignedUploadUrlResponse
-from griptape_nodes.retained_mode.events.os_events import ExistingFilePolicy, WriteFileRequest
+from griptape_nodes.retained_mode.events.os_events import ExistingFilePolicy, WriteFileRequest, WriteFileResultSuccess
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.utils import resolve_workspace_path
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -44,7 +45,7 @@ class LocalStorageDriver(BaseStorageDriver):
         self, path: Path, existing_file_policy: ExistingFilePolicy = ExistingFilePolicy.OVERWRITE
     ) -> CreateSignedUploadUrlResponse:
         # on_write_file_request seems to work most reliably with an absolute path.
-        absolute_path = path if path.is_absolute() else self.workspace_directory / path
+        absolute_path = resolve_workspace_path(path, self.workspace_directory)
 
         # Always delegate to OSManager for file path resolution and policy handling.
         # Creating an empty file before the upload url gives us a chance to claim ownership
@@ -94,9 +95,55 @@ class LocalStorageDriver(BaseStorageDriver):
             "file_path": str(resolved_path),
         }
 
+    def save_file(
+        self, path: Path, file_content: bytes, existing_file_policy: ExistingFilePolicy = ExistingFilePolicy.OVERWRITE
+    ) -> str:
+        """Save a file to local storage by writing directly to disk.
+
+        Args:
+            path: The path of the file to save.
+            file_content: The file content as bytes.
+            existing_file_policy: How to handle existing files. Defaults to OVERWRITE.
+
+        Returns:
+            The absolute file path where the file was saved.
+
+        Raises:
+            FileExistsError: When existing_file_policy is FAIL and file already exists.
+            RuntimeError: If file write fails.
+        """
+        absolute_path = resolve_workspace_path(path, self.workspace_directory)
+
+        result = GriptapeNodes.OSManager().on_write_file_request(
+            WriteFileRequest(
+                file_path=str(absolute_path),
+                content=file_content,
+                existing_file_policy=existing_file_policy,
+            )
+        )
+
+        if not isinstance(result, WriteFileResultSuccess):
+            msg = f"Failed to write file {path}: {result.result_details}"
+            raise ValueError(msg)  # noqa: TRY004
+
+        return result.final_file_path
+
     def create_signed_download_url(self, path: Path) -> str:
-        # The base_url already includes the /static path, so just append the path
-        url = f"{self.base_url}/{path.as_posix()}"
+        # Resolve path, treating relative paths as workspace-relative
+        absolute_path = resolve_workspace_path(path, self.workspace_directory)
+
+        # Automatically determine if the file is external to the workspace
+        try:
+            workspace_relative_path = absolute_path.relative_to(self.workspace_directory.resolve())
+            # Internal files: use workspace-relative path
+            url = f"{self.base_url}/{workspace_relative_path.as_posix()}"
+        except ValueError:
+            # For external files, use /external path and strip leading slash from absolute path
+            path_str = str(absolute_path).removeprefix("/")
+            # Build URL with /external prefix, replacing the /workspace part of base_url
+            base_without_workspace = self.base_url.rsplit("/workspace", 1)[0]
+            url = f"{base_without_workspace}/external/{path_str}"
+
         # Add a cache-busting query parameter to the URL so that the browser always reloads the file
         cache_busted_url = f"{url}?t={int(time.time())}"
         return cache_busted_url
@@ -137,3 +184,17 @@ class LocalStorageDriver(BaseStorageDriver):
 
         response_data = response.json()
         return response_data.get("files", [])
+
+    def get_asset_url(self, path: Path) -> str:
+        """Get the permanent URL for a local asset.
+
+        Returns the absolute file path.
+
+        Args:
+            path: The path of the file
+
+        Returns:
+            Absolute file path as a string
+        """
+        absolute_path = resolve_workspace_path(path, self.workspace_directory)
+        return str(absolute_path)

griptape_nodes/drivers/thread_storage/local_thread_storage_driver.py

@@ -117,6 +117,7 @@ class LocalThreadStorageDriver(BaseThreadStorageDriver):
             msg = f"Cannot delete thread {thread_id}. Archive it first."
             raise ValueError(msg)
 
+        # TODO: Replace with DeleteFileRequest https://github.com/griptape-ai/griptape-nodes/issues/3765
         thread_file.unlink()
 
     def thread_exists(self, thread_id: str) -> bool:

griptape_nodes/exe_types/node_groups/base_node_group.py

@@ -80,6 +80,9 @@ class BaseNodeGroup(BaseNode):
             if node.name in self.nodes:
                 del self.nodes[node.name]
 
+        node_names_in_group = set(self.nodes.keys())
+        self.metadata["node_names_in_group"] = list(node_names_in_group)
+
     def _add_nodes_to_group_dict(self, nodes: list[BaseNode]) -> None:
         """Add nodes to the group's node dictionary."""
         for node in nodes:

griptape_nodes/exe_types/node_types.py

@@ -48,6 +48,7 @@ logger = logging.getLogger("griptape_nodes")
 T = TypeVar("T")
 
 NODE_GROUP_FLOW = "NodeGroupFlow"
+NODE_DEFAULT_SIZE = {"width": 400, "height": 320}
 
 
 class TransformedParameterValue(NamedTuple):
@@ -830,6 +831,18 @@ class BaseNode(ABC):
                         emit_change=False,
                     )
 
+    def set_initial_node_size(
+        self, width: int = NODE_DEFAULT_SIZE["width"], height: int = NODE_DEFAULT_SIZE["height"]
+    ) -> None:
+        """Set the node's UI size. Node authors can call this to give the node a default or custom size.
+
+        Args:
+            width: Width in pixels.
+            height: Height in pixels.
+        """
+        if "size" not in self.metadata:
+            self.metadata["size"] = {"width": width, "height": height}
+
     def kill_parameter_children(self, parameter: Parameter) -> None:
         from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 

griptape_nodes/exe_types/param_components/log_parameter.py

@@ -4,6 +4,7 @@ import sys
 import time
 from collections.abc import Callable, Iterator
 from types import TracebackType
+from typing import Self
 
 from griptape_nodes.exe_types.core_types import Parameter, ParameterMode
 from griptape_nodes.exe_types.node_types import BaseNode
@@ -71,7 +72,7 @@ class StdoutCapture:
     def isatty(self) -> bool:
         return self._original_stdout.isatty()
 
-    def __enter__(self) -> "StdoutCapture":
+    def __enter__(self) -> Self:
         sys.stdout = self
         return self
 
@@ -100,7 +101,7 @@ class LoggerCapture:
         self.target_level = level
         self._handler = CallbackHandler(callback)
 
-    def __enter__(self) -> "LoggerCapture":
+    def __enter__(self) -> Self:
         self.original_level = self.logger.level
         self.logger.setLevel(self.target_level)
         self.logger.addHandler(self._handler)

griptape_nodes/exe_types/param_types/parameter_float.py

@@ -43,8 +43,8 @@ class ParameterFloat(ParameterNumber):
         ui_options: dict | None = None,
         step: float | None = None,
         slider: bool = False,
-        min_val: float = 0,
-        max_val: float = 100,
+        min_val: float | None = None,
+        max_val: float | None = None,
         validate_min_max: bool = False,
         accept_any: bool = True,
         hide: bool | None = None,
@@ -77,8 +77,8 @@ class ParameterFloat(ParameterNumber):
             ui_options: Dictionary of UI options
             step: Step size for numeric input controls
             slider: Whether to use slider trait
-            min_val: Minimum value for constraints
-            max_val: Maximum value for constraints
+            min_val: Minimum value for constraints (None to disable constraints)
+            max_val: Maximum value for constraints (None to disable constraints)
             validate_min_max: Whether to validate min/max with error
             accept_any: Whether to accept any input type and convert to float (default: True)
             hide: Whether to hide the entire parameter

griptape_nodes/exe_types/param_types/parameter_int.py

@@ -43,8 +43,8 @@ class ParameterInt(ParameterNumber):
         ui_options: dict | None = None,
         step: int | None = None,
         slider: bool = False,
-        min_val: float = 0,
-        max_val: float = 100,
+        min_val: float | None = None,
+        max_val: float | None = None,
         validate_min_max: bool = False,
         accept_any: bool = True,
         hide: bool | None = None,
@@ -77,8 +77,8 @@ class ParameterInt(ParameterNumber):
             ui_options: Dictionary of UI options
             step: Step size for numeric input controls
             slider: Whether to use slider trait
-            min_val: Minimum value for constraints
-            max_val: Maximum value for constraints
+            min_val: Minimum value for constraints (None to disable constraints)
+            max_val: Maximum value for constraints (None to disable constraints)
             validate_min_max: Whether to validate min/max with error
             accept_any: Whether to accept any input type and convert to integer (default: True)
             hide: Whether to hide the entire parameter