griptape-nodes 0.62.2__py3-none-any.whl → 0.63.0__py3-none-any.whl

griptape_nodes/cli/commands/libraries.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import shutil
-import stat
 import tarfile
 import tempfile
 from pathlib import Path
@@ -17,6 +16,7 @@ from griptape_nodes.cli.shared import (
     NODES_TARBALL_URL,
     console,
 )
+from griptape_nodes.retained_mode.events.os_events import DeleteFileRequest, DeleteFileResultSuccess
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 from griptape_nodes.utils.version_utils import get_current_version, get_install_source
 
@@ -81,7 +81,11 @@ async def _sync_libraries(*, load_libraries_from_config: bool = True) -> None:
             if library_dir.is_dir():
                 dest_library_dir = dest_nodes / library_dir.name
                 if dest_library_dir.exists():
-                    shutil.rmtree(dest_library_dir, onexc=_remove_readonly)
+                    # Use DeleteFileRequest for centralized deletion with Windows compatibility
+                    request = DeleteFileRequest(path=str(dest_library_dir), workspace_only=False)
+                    result = await GriptapeNodes.OSManager().on_delete_file_request(request)
+                    if not isinstance(result, DeleteFileResultSuccess):
+                        console.print(f"[yellow]Warning: Failed to delete existing library {library_dir.name}[/yellow]")
                 shutil.copytree(library_dir, dest_library_dir)
                 console.print(f"[green]Synced library: {library_dir.name}[/green]")
 
@@ -95,22 +99,3 @@ async def _sync_libraries(*, load_libraries_from_config: bool = True) -> None:
             console.print(f"[red]Error initializing libraries: {e}[/red]")
 
     console.print("[bold green]Libraries synced.[/bold green]")
-
-
-def _remove_readonly(func, path, excinfo) -> None:  # noqa: ANN001, ARG001
-    """Handles read-only files and long paths on Windows during shutil.rmtree.
-
-    https://stackoverflow.com/a/50924863
-    """
-    if not GriptapeNodes.OSManager().is_windows():
-        return
-
-    long_path = Path(GriptapeNodes.OSManager().normalize_path_for_platform(Path(path)))
-
-    try:
-        Path.chmod(long_path, stat.S_IWRITE)
-        func(long_path)
-    except Exception as e:
-        console.print(f"[red]Error removing read-only file: {path}[/red]")
-        console.print(f"[red]Details: {e}[/red]")
-        raise

griptape_nodes/drivers/thread_storage/__init__.py

@@ -0,0 +1,15 @@
+"""Thread storage drivers."""
+
+from griptape_nodes.drivers.thread_storage.base_thread_storage_driver import BaseThreadStorageDriver
+from griptape_nodes.drivers.thread_storage.griptape_cloud_thread_storage_driver import (
+    GriptapeCloudThreadStorageDriver,
+)
+from griptape_nodes.drivers.thread_storage.local_thread_storage_driver import LocalThreadStorageDriver
+from griptape_nodes.drivers.thread_storage.thread_storage_backend import ThreadStorageBackend
+
+__all__ = [
+    "BaseThreadStorageDriver",
+    "GriptapeCloudThreadStorageDriver",
+    "LocalThreadStorageDriver",
+    "ThreadStorageBackend",
+]

griptape_nodes/drivers/thread_storage/base_thread_storage_driver.py

@@ -0,0 +1,106 @@
+"""Base thread storage driver abstract class."""
+
+from abc import ABC, abstractmethod
+
+from griptape.drivers.memory.conversation import BaseConversationMemoryDriver
+
+from griptape_nodes.retained_mode.events.agent_events import ThreadMetadata
+from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
+from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
+
+
+class BaseThreadStorageDriver(ABC):
+    """Abstract base class for thread storage backends."""
+
+    def __init__(self, config_manager: ConfigManager, secrets_manager: SecretsManager) -> None:
+        """Initialize the thread storage driver.
+
+        Args:
+            config_manager: Configuration manager instance
+            secrets_manager: Secrets manager instance
+        """
+        self.config_manager = config_manager
+        self.secrets_manager = secrets_manager
+
+    @abstractmethod
+    def create_thread(self, title: str | None = None, local_id: str | None = None) -> tuple[str, dict]:
+        """Create a new thread with metadata.
+
+        Args:
+            title: Optional thread title
+            local_id: Optional client-side identifier
+
+        Returns:
+            Tuple of (thread_id, metadata_dict)
+        """
+        ...
+
+    @abstractmethod
+    def get_thread_metadata(self, thread_id: str) -> dict:
+        """Get metadata for a thread.
+
+        Args:
+            thread_id: The thread identifier
+
+        Returns:
+            Metadata dictionary
+        """
+        ...
+
+    @abstractmethod
+    def update_thread_metadata(self, thread_id: str, **updates) -> dict:
+        """Update thread metadata.
+
+        Args:
+            thread_id: The thread identifier
+            **updates: Key-value pairs to update in metadata
+
+        Returns:
+            Updated metadata dictionary
+        """
+        ...
+
+    @abstractmethod
+    def list_threads(self) -> list[ThreadMetadata]:
+        """List all threads with metadata.
+
+        Returns:
+            List of ThreadMetadata objects
+        """
+        ...
+
+    @abstractmethod
+    def delete_thread(self, thread_id: str) -> None:
+        """Delete a thread.
+
+        Args:
+            thread_id: The thread identifier
+
+        Raises:
+            ValueError: If thread is not archived or doesn't exist
+        """
+        ...
+
+    @abstractmethod
+    def thread_exists(self, thread_id: str) -> bool:
+        """Check if a thread exists.
+
+        Args:
+            thread_id: The thread identifier
+
+        Returns:
+            True if thread exists, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    def get_conversation_memory_driver(self, thread_id: str | None) -> BaseConversationMemoryDriver:
+        """Get the appropriate conversation memory driver for this thread.
+
+        Args:
+            thread_id: The thread identifier (can be None for GTC backend)
+
+        Returns:
+            Conversation memory driver instance
+        """
+        ...

griptape_nodes/drivers/thread_storage/griptape_cloud_thread_storage_driver.py

@@ -0,0 +1,213 @@
+"""Griptape Cloud thread storage driver."""
+
+import logging
+import os
+from datetime import UTC, datetime
+from urllib.parse import urljoin
+
+import httpx
+from griptape.drivers.memory.conversation import BaseConversationMemoryDriver
+from griptape.drivers.memory.conversation.griptape_cloud import GriptapeCloudConversationMemoryDriver
+
+from griptape_nodes.drivers.thread_storage.base_thread_storage_driver import BaseThreadStorageDriver
+from griptape_nodes.retained_mode.events.agent_events import ThreadMetadata
+
+API_KEY_ENV_VAR = "GT_CLOUD_API_KEY"
+HTTP_NOT_FOUND = 404
+logger = logging.getLogger("griptape_nodes")
+
+
+class GriptapeCloudThreadStorageDriver(BaseThreadStorageDriver):
+    """Griptape Cloud implementation of thread storage."""
+
+    @property
+    def base_url(self) -> str:
+        """Get the base URL for Griptape Cloud API."""
+        return os.environ.get("GT_CLOUD_BASE_URL", "https://cloud.griptape.ai")
+
+    @property
+    def _headers(self) -> dict:
+        """Get the authorization headers for API requests."""
+        api_key = self.secrets_manager.get_secret(API_KEY_ENV_VAR)
+        if not api_key:
+            msg = f"Secret '{API_KEY_ENV_VAR}' not found for Griptape Cloud thread storage"
+            raise ValueError(msg)
+        return {"Authorization": f"Bearer {api_key}"}
+
+    def _get_url(self, path: str) -> str:
+        """Construct full API URL from path."""
+        return urljoin(self.base_url, path)
+
+    def create_thread(self, title: str | None = None, local_id: str | None = None) -> tuple[str, dict]:
+        url = self._get_url("/api/threads")
+
+        now = datetime.now(UTC).isoformat()
+
+        # Build metadata for the request
+        metadata = {
+            "created_at": now,
+            "updated_at": now,
+        }
+        if local_id is not None:
+            metadata["local_id"] = local_id
+
+        # Build request body
+        request_body: dict[str, str | dict] = {"metadata": metadata}
+        if title is not None:
+            request_body["name"] = title
+
+        try:
+            response = httpx.post(url, json=request_body, headers=self._headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to create thread in Griptape Cloud: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+        thread_id = response_data["thread_id"]
+
+        # Build metadata dict to return (matching local driver behavior)
+        result_metadata = response_data.get("metadata", {})
+        if title is not None:
+            result_metadata["title"] = title
+
+        return thread_id, result_metadata
+
+    def get_thread_metadata(self, thread_id: str) -> dict:
+        url = self._get_url(f"/api/threads/{thread_id}")
+
+        try:
+            response = httpx.get(url, headers=self._headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == HTTP_NOT_FOUND:
+                return {}
+            msg = f"Failed to get thread {thread_id} from Griptape Cloud: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+
+        # Extract metadata from response
+        metadata = response_data.get("metadata", {})
+
+        # Map GTC's "name" field to our "title" field for consistency
+        if response_data.get("name"):
+            metadata["title"] = response_data["name"]
+
+        return metadata
+
+    def update_thread_metadata(self, thread_id: str, **updates) -> dict:
+        # First, get current metadata
+        current_metadata = self.get_thread_metadata(thread_id)
+
+        now = datetime.now(UTC).isoformat()
+
+        # Merge updates into current metadata
+        for key, value in updates.items():
+            if value is not None:
+                current_metadata[key] = value
+
+        current_metadata["updated_at"] = now
+
+        if "created_at" not in current_metadata:
+            current_metadata["created_at"] = now
+
+        url = self._get_url(f"/api/threads/{thread_id}")
+
+        # Build request body
+        request_body: dict[str, str | dict] = {"metadata": current_metadata}
+
+        # If title was updated, also set the name field
+        if "title" in updates and updates["title"] is not None:
+            request_body["name"] = updates["title"]
+
+        try:
+            response = httpx.patch(url, json=request_body, headers=self._headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to update thread {thread_id} in Griptape Cloud: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+
+        # Return updated metadata
+        result_metadata = response_data.get("metadata", {})
+        if response_data.get("name"):
+            result_metadata["title"] = response_data["name"]
+
+        return result_metadata
+
+    def list_threads(self) -> list[ThreadMetadata]:
+        url = self._get_url("/api/threads")
+
+        try:
+            response = httpx.get(url, headers=self._headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to list threads from Griptape Cloud: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+        response_data = response.json()
+        threads_data = response_data.get("threads", [])
+
+        threads = []
+        for thread_data in threads_data:
+            thread_id = thread_data.get("thread_id")
+            if not thread_id:
+                continue
+
+            metadata = thread_data.get("metadata", {})
+
+            thread_metadata = ThreadMetadata(
+                thread_id=thread_id,
+                title=thread_data.get("name"),
+                created_at=metadata.get("created_at"),
+                updated_at=metadata.get("updated_at"),
+                message_count=thread_data.get("message_count", 0),
+                archived=metadata.get("archived", False),
+                local_id=metadata.get("local_id"),
+            )
+            threads.append(thread_metadata)
+
+        # Sort by updated_at descending (most recent first)
+        threads.sort(key=lambda t: t.updated_at or "", reverse=True)
+
+        return threads
+
+    def delete_thread(self, thread_id: str) -> None:
+        if not self.thread_exists(thread_id):
+            msg = f"Thread {thread_id} not found"
+            raise ValueError(msg)
+
+        meta = self.get_thread_metadata(thread_id)
+        if not meta.get("archived", False):
+            msg = f"Cannot delete thread {thread_id}. Archive it first."
+            raise ValueError(msg)
+
+        url = self._get_url(f"/api/threads/{thread_id}")
+
+        try:
+            response = httpx.delete(url, headers=self._headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            msg = f"Failed to delete thread {thread_id} from Griptape Cloud: {e}"
+            logger.error(msg)
+            raise RuntimeError(msg) from e
+
+    def thread_exists(self, thread_id: str) -> bool:
+        try:
+            meta = self.get_thread_metadata(thread_id)
+            return bool(meta)
+        except Exception:
+            return False
+
+    def get_conversation_memory_driver(self, thread_id: str | None) -> BaseConversationMemoryDriver:
+        api_key = self.secrets_manager.get_secret(API_KEY_ENV_VAR)
+        if not api_key:
+            msg = f"Secret '{API_KEY_ENV_VAR}' not found for Griptape Cloud thread storage"
+            raise ValueError(msg)
+        return GriptapeCloudConversationMemoryDriver(api_key=api_key, thread_id=thread_id)

griptape_nodes/drivers/thread_storage/local_thread_storage_driver.py

@@ -0,0 +1,137 @@
+"""Local filesystem thread storage driver."""
+
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+
+from griptape.drivers.memory.conversation import BaseConversationMemoryDriver
+from griptape.drivers.memory.conversation.local import LocalConversationMemoryDriver
+from griptape.memory.structure import ConversationMemory
+
+from griptape_nodes.drivers.thread_storage.base_thread_storage_driver import BaseThreadStorageDriver
+from griptape_nodes.retained_mode.events.agent_events import ThreadMetadata
+from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
+from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
+
+
+class LocalThreadStorageDriver(BaseThreadStorageDriver):
+    """Local filesystem implementation of thread storage."""
+
+    def __init__(self, threads_directory: Path, config_manager: ConfigManager, secrets_manager: SecretsManager) -> None:
+        """Initialize the local thread storage driver.
+
+        Args:
+            threads_directory: Directory for storing thread data
+            config_manager: Configuration manager instance
+            secrets_manager: Secrets manager instance
+        """
+        super().__init__(config_manager, secrets_manager)
+        self.threads_directory = threads_directory
+
+    def create_thread(self, title: str | None = None, local_id: str | None = None) -> tuple[str, dict]:
+        thread_id = str(uuid.uuid4())
+
+        conversation_memory = self._get_or_create_conversation_memory(thread_id)
+
+        now = datetime.now(UTC).isoformat()
+        conversation_memory.meta = {
+            "created_at": now,
+            "updated_at": now,
+        }
+
+        if title is not None:
+            conversation_memory.meta["title"] = title
+        if local_id is not None:
+            conversation_memory.meta["local_id"] = local_id
+
+        conversation_memory.conversation_memory_driver.store(conversation_memory.runs, conversation_memory.meta)
+
+        return thread_id, conversation_memory.meta
+
+    def get_thread_metadata(self, thread_id: str) -> dict:
+        conversation_memory = self._get_or_create_conversation_memory(thread_id)
+        if conversation_memory.meta is None:
+            return {}
+        return conversation_memory.meta
+
+    def update_thread_metadata(self, thread_id: str, **updates) -> dict:
+        conversation_memory = self._get_or_create_conversation_memory(thread_id)
+        now = datetime.now(UTC).isoformat()
+
+        if conversation_memory.meta is None:
+            conversation_memory.meta = {}
+
+        for key, value in updates.items():
+            if value is not None:
+                conversation_memory.meta[key] = value
+
+        conversation_memory.meta["updated_at"] = now
+
+        if "created_at" not in conversation_memory.meta:
+            conversation_memory.meta["created_at"] = now
+
+        conversation_memory.conversation_memory_driver.store(conversation_memory.runs, conversation_memory.meta)
+
+        return conversation_memory.meta
+
+    def list_threads(self) -> list[ThreadMetadata]:
+        threads = []
+
+        if not self.threads_directory.exists():
+            return threads
+
+        thread_ids = [
+            thread_file.stem.replace("thread_", "") for thread_file in self.threads_directory.glob("thread_*.json")
+        ]
+
+        for thread_id in thread_ids:
+            meta = self.get_thread_metadata(thread_id)
+            conversation_memory = self._get_or_create_conversation_memory(thread_id)
+            message_count = len(conversation_memory.runs)
+
+            threads.append(
+                ThreadMetadata(
+                    thread_id=thread_id,
+                    title=meta.get("title"),
+                    created_at=meta.get("created_at", ""),
+                    updated_at=meta.get("updated_at", ""),
+                    message_count=message_count,
+                    archived=meta.get("archived", False),
+                    local_id=meta.get("local_id"),
+                )
+            )
+
+        threads.sort(key=lambda t: t.updated_at, reverse=True)
+
+        return threads
+
+    def delete_thread(self, thread_id: str) -> None:
+        thread_file = self.threads_directory / f"thread_{thread_id}.json"
+
+        if not thread_file.exists():
+            msg = f"Thread {thread_id} not found"
+            raise ValueError(msg)
+
+        meta = self.get_thread_metadata(thread_id)
+        if not meta.get("archived", False):
+            msg = f"Cannot delete thread {thread_id}. Archive it first."
+            raise ValueError(msg)
+
+        thread_file.unlink()
+
+    def thread_exists(self, thread_id: str) -> bool:
+        thread_file = self.threads_directory / f"thread_{thread_id}.json"
+        return thread_file.exists()
+
+    def get_conversation_memory_driver(self, thread_id: str | None) -> BaseConversationMemoryDriver:
+        if thread_id is None:
+            msg = "thread_id is required for local storage backend"
+            raise ValueError(msg)
+
+        thread_file = self.threads_directory / f"thread_{thread_id}.json"
+        return LocalConversationMemoryDriver(persist_file=str(thread_file))
+
+    def _get_or_create_conversation_memory(self, thread_id: str) -> ConversationMemory:
+        """Get or create ConversationMemory instance for a thread."""
+        driver = self.get_conversation_memory_driver(thread_id)
+        return ConversationMemory(conversation_memory_driver=driver)

griptape_nodes/drivers/thread_storage/thread_storage_backend.py

@@ -0,0 +1,10 @@
+"""Thread storage backend enumeration."""
+
+from enum import StrEnum
+
+
+class ThreadStorageBackend(StrEnum):
+    """Enumeration of available thread storage backends."""
+
+    LOCAL = "local"
+    GTC = "gtc"

griptape_nodes/node_library/library_registry.py

@@ -5,11 +5,15 @@ from typing import TYPE_CHECKING, Any, ClassVar, NamedTuple
 
 from pydantic import BaseModel, Field
 
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.duplicate_node_registration_problem import (
+    DuplicateNodeRegistrationProblem,
+)
 from griptape_nodes.utils.metaclasses import SingletonMeta
 
 if TYPE_CHECKING:
     from griptape_nodes.exe_types.node_types import BaseNode
     from griptape_nodes.node_library.advanced_node_library import AdvancedNodeLibrary
+    from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -177,16 +181,19 @@ class LibraryRegistry(metaclass=SingletonMeta):
         return sorted_list
 
     @classmethod
-    def register_node_type_from_library(cls, library: Library, node_class_name: str) -> str | None:
-        """Register a node type from a library. Returns an error string for forensics."""
+    def register_node_type_from_library(cls, library: Library, node_class_name: str) -> LibraryProblem | None:
+        """Register a node type from a library. Returns a LibraryProblem if registration fails."""
         # Does a node class of this name already exist?
         library_collisions = LibraryRegistry.get_libraries_with_node_type(node_class_name)
         if library_collisions:
             library_data = library.get_library_data()
             if library_data.name in library_collisions:
-                details = f"Attempted to register Node class '{node_class_name}' from Library '{library_data.name}', but a Node with that name from that Library was already registered. Check to ensure you aren't re-adding the same libraries multiple times."
-                logger.error(details)
-                return details
+                logger.error(
+                    "Attempted to register node class '%s' from library '%s', but a node with that name from that library was already registered",
+                    node_class_name,
+                    library_data.name,
+                )
+                return DuplicateNodeRegistrationProblem(class_name=node_class_name, library_name=library_data.name)
 
         return None
 
@@ -301,19 +308,19 @@ class Library:
         self._node_metadata = {}
         self._advanced_library = advanced_library
 
-    def register_new_node_type(self, node_class: type[BaseNode], metadata: NodeMetadata) -> str | None:
-        """Register a new node type in this library. Returns an error string for forensics, or None if all clear."""
+    def register_new_node_type(self, node_class: type[BaseNode], metadata: NodeMetadata) -> LibraryProblem | None:
+        """Register a new node type in this library. Returns a LibraryProblem if registration fails, or None if all clear."""
         # We only need to register the name of the node within the library.
         node_class_as_str = node_class.__name__
 
         # Let the registry know.
-        registry_details = LibraryRegistry.register_node_type_from_library(
+        library_problem = LibraryRegistry.register_node_type_from_library(
             library=self, node_class_name=node_class_as_str
         )
 
         self._node_types[node_class_as_str] = node_class
         self._node_metadata[node_class_as_str] = metadata
-        return registry_details
+        return library_problem
 
     def get_library_data(self) -> LibrarySchema:
         return self._library_data

griptape_nodes/node_library/workflow_registry.py

@@ -45,7 +45,7 @@ class WorkflowShape(BaseModel):
 
 
 class WorkflowMetadata(BaseModel):
-    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.12.0"
+    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.13.0"
 
     name: str
     schema_version: str