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

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -4,6 +4,7 @@ import logging
 import os
 import threading
 import uuid
+from collections.abc import Iterator
 from typing import TYPE_CHECKING, ClassVar
 
 from attrs import define, field
@@ -22,21 +23,41 @@ from griptape.utils.decorators import activity
 from json_repair import repair_json
 from pydantic import create_model
 from schema import Literal, Schema
+from xdg_base_dirs import xdg_data_home
 
+from griptape_nodes.drivers.thread_storage import (
+    GriptapeCloudThreadStorageDriver,
+    LocalThreadStorageDriver,
+)
 from griptape_nodes.retained_mode.events.agent_events import (
     AgentStreamEvent,
+    ArchiveThreadRequest,
+    ArchiveThreadResultFailure,
+    ArchiveThreadResultSuccess,
     ConfigureAgentRequest,
     ConfigureAgentResultFailure,
     ConfigureAgentResultSuccess,
+    CreateThreadRequest,
+    CreateThreadResultFailure,
+    CreateThreadResultSuccess,
+    DeleteThreadRequest,
+    DeleteThreadResultFailure,
+    DeleteThreadResultSuccess,
     GetConversationMemoryRequest,
     GetConversationMemoryResultFailure,
     GetConversationMemoryResultSuccess,
-    ResetAgentConversationMemoryRequest,
-    ResetAgentConversationMemoryResultFailure,
-    ResetAgentConversationMemoryResultSuccess,
+    ListThreadsRequest,
+    ListThreadsResultFailure,
+    ListThreadsResultSuccess,
+    RenameThreadRequest,
+    RenameThreadResultFailure,
+    RenameThreadResultSuccess,
     RunAgentRequest,
     RunAgentResultFailure,
     RunAgentResultSuccess,
+    UnarchiveThreadRequest,
+    UnarchiveThreadResultFailure,
+    UnarchiveThreadResultSuccess,
 )
 from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent, ResultPayload
@@ -104,27 +125,321 @@ class AgentManager:
     }
 
     def __init__(self, static_files_manager: StaticFilesManager, event_manager: EventManager | None = None) -> None:
-        self.conversation_memory = ConversationMemory()
         self.prompt_driver = None
         self.image_tool = None
         self.mcp_tool = None
         self.static_files_manager = static_files_manager
 
+        # Thread management
+        self._threads_dir = xdg_data_home() / "griptape_nodes" / "threads"
+        self._threads_dir.mkdir(parents=True, exist_ok=True)
+
+        # Initialize thread storage driver based on config
+        self.thread_storage_driver = self._initialize_thread_storage_driver()
+
         if event_manager is not None:
+            # Existing handlers
             event_manager.assign_manager_to_request_type(RunAgentRequest, self.on_handle_run_agent_request)
             event_manager.assign_manager_to_request_type(ConfigureAgentRequest, self.on_handle_configure_agent_request)
             event_manager.assign_manager_to_request_type(
-                ResetAgentConversationMemoryRequest, self.on_handle_reset_agent_conversation_memory_request
+                GetConversationMemoryRequest, self.on_handle_get_conversation_memory_request
             )
+
+            # New thread management handlers
+            event_manager.assign_manager_to_request_type(CreateThreadRequest, self.on_handle_create_thread_request)
+            event_manager.assign_manager_to_request_type(ListThreadsRequest, self.on_handle_list_threads_request)
+            event_manager.assign_manager_to_request_type(DeleteThreadRequest, self.on_handle_delete_thread_request)
+            event_manager.assign_manager_to_request_type(RenameThreadRequest, self.on_handle_rename_thread_request)
+            event_manager.assign_manager_to_request_type(ArchiveThreadRequest, self.on_handle_archive_thread_request)
             event_manager.assign_manager_to_request_type(
-                GetConversationMemoryRequest, self.on_handle_get_conversation_memory_request
+                UnarchiveThreadRequest, self.on_handle_unarchive_thread_request
             )
+
             event_manager.add_listener_to_app_event(
                 AppInitializationComplete,
                 self.on_app_initialization_complete,
             )
             # TODO: Listen for shutdown event (https://github.com/griptape-ai/griptape-nodes/issues/2149) to stop mcp server
 
+    async def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
+        if self.prompt_driver is None:
+            self.prompt_driver = self._initialize_prompt_driver()
+        if self.image_tool is None:
+            self.image_tool = self._initialize_image_tool()
+        if self.mcp_tool is None:
+            self.mcp_tool = self._initialize_mcp_tool()
+        try:
+            return await asyncio.to_thread(self._on_handle_run_agent_request, request)
+        except Exception as e:
+            err_msg = f"Error handling run agent request: {e}"
+            return RunAgentResultFailure(error=ErrorArtifact(e).to_dict(), result_details=err_msg)
+
+    def on_handle_configure_agent_request(self, request: ConfigureAgentRequest) -> ResultPayload:
+        try:
+            if self.prompt_driver is None:
+                self.prompt_driver = self._initialize_prompt_driver()
+            for key, value in request.prompt_driver.items():
+                setattr(self.prompt_driver, key, value)
+        except Exception as e:
+            details = f"Error configuring agent: {e}"
+            logger.error(details)
+            return ConfigureAgentResultFailure(result_details=details)
+        return ConfigureAgentResultSuccess(result_details="Agent configured successfully.")
+
+    def on_handle_get_conversation_memory_request(self, request: GetConversationMemoryRequest) -> ResultPayload:
+        try:
+            thread_id = request.thread_id
+
+            driver = self.thread_storage_driver.get_conversation_memory_driver(thread_id)
+            conversation_memory = ConversationMemory(conversation_memory_driver=driver)
+            runs = conversation_memory.runs
+
+        except Exception as e:
+            details = f"Error getting conversation memory: {e}"
+            logger.error(details)
+            return GetConversationMemoryResultFailure(result_details=details)
+
+        return GetConversationMemoryResultSuccess(
+            runs=runs, thread_id=thread_id, result_details="Conversation memory retrieved successfully."
+        )
+
+    def on_handle_create_thread_request(self, request: CreateThreadRequest) -> ResultPayload:
+        try:
+            thread_id, meta = self.thread_storage_driver.create_thread(title=request.title, local_id=request.local_id)
+
+            return CreateThreadResultSuccess(
+                thread_id=thread_id,
+                title=meta.get("title"),
+                created_at=meta["created_at"],
+                updated_at=meta["updated_at"],
+                result_details="Thread created successfully.",
+            )
+        except Exception as e:
+            details = f"Error creating thread: {e}"
+            logger.error(details)
+            return CreateThreadResultFailure(result_details=details)
+
+    def on_handle_list_threads_request(self, _: ListThreadsRequest) -> ResultPayload:
+        try:
+            threads = self.thread_storage_driver.list_threads()
+            return ListThreadsResultSuccess(threads=threads, result_details="Threads retrieved successfully.")
+        except Exception as e:
+            details = f"Error listing threads: {e}"
+            logger.error(details)
+            return ListThreadsResultFailure(result_details=details)
+
+    def on_handle_delete_thread_request(self, request: DeleteThreadRequest) -> ResultPayload:
+        try:
+            self.thread_storage_driver.delete_thread(request.thread_id)
+            return DeleteThreadResultSuccess(thread_id=request.thread_id, result_details="Thread deleted successfully.")
+        except ValueError as e:
+            details = str(e)
+            logger.error(details)
+            return DeleteThreadResultFailure(result_details=details)
+        except Exception as e:
+            details = f"Error deleting thread: {e}"
+            logger.error(details)
+            return DeleteThreadResultFailure(result_details=details)
+
+    def on_handle_rename_thread_request(self, request: RenameThreadRequest) -> ResultPayload:
+        try:
+            if not self.thread_storage_driver.thread_exists(request.thread_id):
+                details = f"Thread {request.thread_id} not found"
+                logger.error(details)
+                return RenameThreadResultFailure(result_details=details)
+
+            updated_meta = self.thread_storage_driver.update_thread_metadata(request.thread_id, title=request.new_title)
+
+            return RenameThreadResultSuccess(
+                thread_id=request.thread_id,
+                title=updated_meta["title"],
+                updated_at=updated_meta["updated_at"],
+                result_details="Thread renamed successfully.",
+            )
+        except Exception as e:
+            details = f"Error renaming thread: {e}"
+            logger.error(details)
+            return RenameThreadResultFailure(result_details=details)
+
+    def on_handle_archive_thread_request(self, request: ArchiveThreadRequest) -> ResultPayload:
+        try:
+            if not self.thread_storage_driver.thread_exists(request.thread_id):
+                details = f"Thread {request.thread_id} not found"
+                logger.error(details)
+                return ArchiveThreadResultFailure(result_details=details)
+
+            meta = self.thread_storage_driver.get_thread_metadata(request.thread_id)
+            if meta.get("archived", False):
+                details = f"Thread {request.thread_id} is already archived"
+                logger.error(details)
+                return ArchiveThreadResultFailure(result_details=details)
+
+            updated_meta = self.thread_storage_driver.update_thread_metadata(request.thread_id, archived=True)
+
+            return ArchiveThreadResultSuccess(
+                thread_id=request.thread_id,
+                updated_at=updated_meta["updated_at"],
+                result_details="Thread archived successfully.",
+            )
+        except Exception as e:
+            details = f"Error archiving thread: {e}"
+            logger.error(details)
+            return ArchiveThreadResultFailure(result_details=details)
+
+    def on_handle_unarchive_thread_request(self, request: UnarchiveThreadRequest) -> ResultPayload:
+        try:
+            if not self.thread_storage_driver.thread_exists(request.thread_id):
+                details = f"Thread {request.thread_id} not found"
+                logger.error(details)
+                return UnarchiveThreadResultFailure(result_details=details)
+
+            meta = self.thread_storage_driver.get_thread_metadata(request.thread_id)
+            if not meta.get("archived", False):
+                details = f"Thread {request.thread_id} is not archived"
+                logger.error(details)
+                return UnarchiveThreadResultFailure(result_details=details)
+
+            updated_meta = self.thread_storage_driver.update_thread_metadata(request.thread_id, archived=False)
+
+            return UnarchiveThreadResultSuccess(
+                thread_id=request.thread_id,
+                updated_at=updated_meta["updated_at"],
+                result_details="Thread unarchived successfully.",
+            )
+        except Exception as e:
+            details = f"Error unarchiving thread: {e}"
+            logger.error(details)
+            return UnarchiveThreadResultFailure(result_details=details)
+
+    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
+        secrets_manager = GriptapeNodes.SecretsManager()
+        api_key = secrets_manager.get_secret("GT_CLOUD_API_KEY")
+        # Start MCP server in daemon thread
+        threading.Thread(target=start_mcp_server, args=(api_key,), daemon=True, name="mcp-server").start()
+
+    def _on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
+        # EventBus functionality removed - events now go directly to event queue
+        try:
+            # Get or create thread and validate
+            try:
+                thread_id = self._validate_thread_for_run(request.thread_id)
+            except ValueError as e:
+                details = str(e)
+                return RunAgentResultFailure(error={"message": details}, result_details=details)
+
+            # Check if this is the first run
+            driver = self.thread_storage_driver.get_conversation_memory_driver(thread_id)
+            conversation_memory = ConversationMemory(conversation_memory_driver=driver)
+            is_first_run = len(conversation_memory.runs) == 0
+
+            artifacts = [
+                ImageLoader().parse(ImageUrlArtifact.from_dict(url_artifact).to_bytes())
+                for url_artifact in request.url_artifacts
+                if url_artifact["type"] == "ImageUrlArtifact"
+            ]
+            agent = self._create_agent(thread_id=thread_id, additional_mcp_servers=request.additional_mcp_servers)
+            event_stream = agent.run_stream([request.input, *artifacts])
+            self._process_agent_stream(event_stream)
+
+            if isinstance(agent.output, ErrorArtifact):
+                return RunAgentResultFailure(error=agent.output.to_dict(), result_details=agent.output.to_json())
+
+            # Auto-generate title from first message if needed
+            if is_first_run:
+                title = self._generate_title_from_input(request.input)
+                self.thread_storage_driver.update_thread_metadata(thread_id, title=title)
+            else:
+                # Just update the timestamp
+                self.thread_storage_driver.update_thread_metadata(thread_id)
+
+            return RunAgentResultSuccess(
+                output=agent.output.to_dict(),
+                thread_id=thread_id,
+                result_details="Agent execution completed successfully.",
+            )
+        except Exception as e:
+            err_msg = f"Error running agent: {e}"
+            logger.exception(err_msg)
+            return RunAgentResultFailure(error=ErrorArtifact(e).to_dict(), result_details=err_msg)
+
+    def _create_agent(self, thread_id: str, additional_mcp_servers: list[str] | None = None) -> Agent:
+        output_schema = create_model(
+            "AgentOutputSchema",
+            conversation_output=(str, ...),
+            generated_image_urls=(list[str], ...),
+        )
+
+        tools = []
+        if self.image_tool is not None:
+            tools.append(self.image_tool)
+        if self.mcp_tool is not None:
+            tools.append(self.mcp_tool)
+
+        # Add additional MCP servers if specified
+        if additional_mcp_servers:
+            additional_tools = self._create_additional_mcp_tools(additional_mcp_servers)
+            tools.extend(additional_tools)
+
+        # Get thread-specific conversation memory
+        driver = self.thread_storage_driver.get_conversation_memory_driver(thread_id)
+        conversation_memory = ConversationMemory(conversation_memory_driver=driver)
+
+        return Agent(
+            prompt_driver=self.prompt_driver,
+            conversation_memory=conversation_memory,
+            tools=tools,
+            output_schema=output_schema,
+            rulesets=[
+                Ruleset(
+                    name="generated_image_urls",
+                    rules=[
+                        Rule("Do not hallucinate generated_image_urls."),
+                        Rule("Only set generated_image_urls with images generated with your tools."),
+                    ],
+                ),
+            ],
+        )
+
+    def _validate_thread_for_run(self, thread_id: str | None) -> str:
+        """Validate and return thread_id for agent run, or raise ValueError."""
+        if thread_id is None:
+            thread_id, _ = self.thread_storage_driver.create_thread()
+            return thread_id
+
+        meta = self.thread_storage_driver.get_thread_metadata(thread_id)
+        if meta.get("archived", False):
+            details = f"Cannot run agent on archived thread {thread_id}. Unarchive it first."
+            logger.error(details)
+            raise ValueError(details)
+
+        return thread_id
+
+    def _process_agent_stream(self, event_stream: Iterator) -> None:
+        """Process agent stream events and emit streaming tokens."""
+        full_result = ""
+        last_conversation_output = ""
+        for event in event_stream:
+            if isinstance(event, TextChunkEvent):
+                full_result += event.token
+                try:
+                    result_json = json.loads(repair_json(full_result))
+
+                    if isinstance(result_json, dict) and "conversation_output" in result_json:
+                        new_conversation_output = result_json["conversation_output"]
+                        if new_conversation_output != last_conversation_output:
+                            GriptapeNodes.EventManager().put_event(
+                                ExecutionGriptapeNodeEvent(
+                                    wrapped_event=ExecutionEvent(
+                                        payload=AgentStreamEvent(
+                                            token=new_conversation_output[len(last_conversation_output) :]
+                                        )
+                                    )
+                                )
+                            )
+                            last_conversation_output = new_conversation_output
+                except json.JSONDecodeError:
+                    pass  # Ignore incomplete JSON
+
     def _initialize_prompt_driver(self) -> GriptapeCloudPromptDriver:
         api_key = secrets_manager.get_secret(API_KEY_ENV_VAR)
         if not api_key:
@@ -149,6 +464,15 @@ class AgentManager:
         }
         return MCPTool(connection=connection, name="mcpGriptapeNodes")
 
+    def _initialize_thread_storage_driver(self) -> LocalThreadStorageDriver | GriptapeCloudThreadStorageDriver:
+        """Initialize the appropriate thread storage driver based on configuration."""
+        storage_backend = config_manager.get_config_value("thread_storage_backend")
+
+        if storage_backend == "gtc":
+            return GriptapeCloudThreadStorageDriver(config_manager, secrets_manager)
+
+        return LocalThreadStorageDriver(self._threads_dir, config_manager, secrets_manager)
+
     def _create_additional_mcp_tools(self, server_names: list[str]) -> list[MCPTool]:
         """Create MCP tools for additional servers specified in the request."""
         additional_tools = []
@@ -195,133 +519,9 @@ class AgentManager:
 
         return connection
 
-    async def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
-        if self.prompt_driver is None:
-            self.prompt_driver = self._initialize_prompt_driver()
-        if self.image_tool is None:
-            self.image_tool = self._initialize_image_tool()
-        if self.mcp_tool is None:
-            self.mcp_tool = self._initialize_mcp_tool()
-        try:
-            return await asyncio.to_thread(self._on_handle_run_agent_request, request)
-        except Exception as e:
-            err_msg = f"Error handling run agent request: {e}"
-            return RunAgentResultFailure(error=ErrorArtifact(e).to_dict(), result_details=err_msg)
-
-    def _create_agent(self, additional_mcp_servers: list[str] | None = None) -> Agent:
-        output_schema = create_model(
-            "AgentOutputSchema",
-            conversation_output=(str, ...),
-            generated_image_urls=(list[str], ...),
-        )
-
-        tools = []
-        if self.image_tool is not None:
-            tools.append(self.image_tool)
-        if self.mcp_tool is not None:
-            tools.append(self.mcp_tool)
-
-        # Add additional MCP servers if specified
-        if additional_mcp_servers:
-            additional_tools = self._create_additional_mcp_tools(additional_mcp_servers)
-            tools.extend(additional_tools)
-
-        return Agent(
-            prompt_driver=self.prompt_driver,
-            conversation_memory=self.conversation_memory,
-            tools=tools,
-            output_schema=output_schema,
-            rulesets=[
-                Ruleset(
-                    name="generated_image_urls",
-                    rules=[
-                        Rule("Do not hallucinate generated_image_urls."),
-                        Rule("Only set generated_image_urls with images generated with your tools."),
-                    ],
-                ),
-            ],
-        )
-
-    def _on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
-        # EventBus functionality removed - events now go directly to event queue
-        try:
-            artifacts = [
-                ImageLoader().parse(ImageUrlArtifact.from_dict(url_artifact).to_bytes())
-                for url_artifact in request.url_artifacts
-                if url_artifact["type"] == "ImageUrlArtifact"
-            ]
-            agent = self._create_agent(additional_mcp_servers=request.additional_mcp_servers)
-            event_stream = agent.run_stream([request.input, *artifacts])
-            full_result = ""
-            last_conversation_output = ""
-            for event in event_stream:
-                if isinstance(event, TextChunkEvent):
-                    full_result += event.token
-                    try:
-                        result_json = json.loads(repair_json(full_result))
-
-                        if isinstance(result_json, dict) and "conversation_output" in result_json:
-                            new_conversation_output = result_json["conversation_output"]
-                            if new_conversation_output != last_conversation_output:
-                                GriptapeNodes.EventManager().put_event(
-                                    ExecutionGriptapeNodeEvent(
-                                        wrapped_event=ExecutionEvent(
-                                            payload=AgentStreamEvent(
-                                                token=new_conversation_output[len(last_conversation_output) :]
-                                            )
-                                        )
-                                    )
-                                )
-                                last_conversation_output = new_conversation_output
-                    except json.JSONDecodeError:
-                        pass  # Ignore incomplete JSON
-            if isinstance(agent.output, ErrorArtifact):
-                return RunAgentResultFailure(error=agent.output.to_dict(), result_details=agent.output.to_json())
-
-            return RunAgentResultSuccess(
-                agent.output.to_dict(), result_details="Agent execution completed successfully."
-            )
-        except Exception as e:
-            err_msg = f"Error running agent: {e}"
-            logger.exception(err_msg)
-            return RunAgentResultFailure(error=ErrorArtifact(e).to_dict(), result_details=err_msg)
+    def _generate_title_from_input(self, user_input: str, max_length: int = 50) -> str:
+        """Generate a thread title from user input."""
+        if len(user_input) <= max_length:
+            return user_input
 
-    def on_handle_configure_agent_request(self, request: ConfigureAgentRequest) -> ResultPayload:
-        try:
-            if self.prompt_driver is None:
-                self.prompt_driver = self._initialize_prompt_driver()
-            for key, value in request.prompt_driver.items():
-                setattr(self.prompt_driver, key, value)
-        except Exception as e:
-            details = f"Error configuring agent: {e}"
-            logger.error(details)
-            return ConfigureAgentResultFailure(result_details=details)
-        return ConfigureAgentResultSuccess(result_details="Agent configured successfully.")
-
-    def on_handle_reset_agent_conversation_memory_request(
-        self, _: ResetAgentConversationMemoryRequest
-    ) -> ResultPayload:
-        try:
-            self.conversation_memory = ConversationMemory()
-        except Exception as e:
-            details = f"Error resetting agent conversation memory: {e}"
-            logger.error(details)
-            return ResetAgentConversationMemoryResultFailure(result_details=details)
-        return ResetAgentConversationMemoryResultSuccess(result_details="Agent conversation memory reset successfully.")
-
-    def on_handle_get_conversation_memory_request(self, _: GetConversationMemoryRequest) -> ResultPayload:
-        try:
-            conversation_memory = self.conversation_memory.runs
-        except Exception as e:
-            details = f"Error getting conversation memory: {e}"
-            logger.error(details)
-            return GetConversationMemoryResultFailure(result_details=details)
-        return GetConversationMemoryResultSuccess(
-            runs=conversation_memory, result_details="Conversation memory retrieved successfully."
-        )
-
-    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
-        secrets_manager = GriptapeNodes.SecretsManager()
-        api_key = secrets_manager.get_secret("GT_CLOUD_API_KEY")
-        # Start MCP server in daemon thread
-        threading.Thread(target=start_mcp_server, args=(api_key,), daemon=True, name="mcp-server").start()
+        return user_input[:max_length].rsplit(" ", 1)[0] + "..."

griptape_nodes/retained_mode/managers/fitness_problems/__init__.py

@@ -0,0 +1 @@
+"""Fitness problems package for library and workflow validation issues."""

griptape_nodes/retained_mode/managers/fitness_problems/libraries/__init__.py

@@ -0,0 +1,59 @@
+"""Library fitness problems for validation and loading issues."""
+
+from .advanced_library_load_failure_problem import AdvancedLibraryLoadFailureProblem
+from .after_library_callback_problem import AfterLibraryCallbackProblem
+from .before_library_callback_problem import BeforeLibraryCallbackProblem
+from .create_config_category_problem import CreateConfigCategoryProblem
+from .dependency_installation_failed_problem import DependencyInstallationFailedProblem
+from .deprecated_node_warning_problem import DeprecatedNodeWarningProblem
+from .duplicate_library_problem import DuplicateLibraryProblem
+from .duplicate_node_registration_problem import DuplicateNodeRegistrationProblem
+from .engine_version_error_problem import EngineVersionErrorProblem
+from .insufficient_disk_space_problem import InsufficientDiskSpaceProblem
+from .invalid_version_string_problem import InvalidVersionStringProblem
+from .library_json_decode_problem import LibraryJsonDecodeProblem
+from .library_load_exception_problem import LibraryLoadExceptionProblem
+from .library_not_found_problem import LibraryNotFoundProblem
+from .library_problem import LibraryProblem
+from .library_schema_exception_problem import LibrarySchemaExceptionProblem
+from .library_schema_validation_problem import LibrarySchemaValidationProblem
+from .modified_parameters_set_deprecation_warning_problem import ModifiedParametersSetDeprecationWarningProblem
+from .modified_parameters_set_removed_problem import ModifiedParametersSetRemovedProblem
+from .node_class_not_base_node_problem import NodeClassNotBaseNodeProblem
+from .node_class_not_found_problem import NodeClassNotFoundProblem
+from .node_module_import_problem import NodeModuleImportProblem
+from .sandbox_directory_missing_problem import SandboxDirectoryMissingProblem
+from .ui_options_field_modified_incompatible_problem import UiOptionsFieldModifiedIncompatibleProblem
+from .ui_options_field_modified_warning_problem import UiOptionsFieldModifiedWarningProblem
+from .update_config_category_problem import UpdateConfigCategoryProblem
+from .venv_creation_failed_problem import VenvCreationFailedProblem
+
+__all__ = [
+    "AdvancedLibraryLoadFailureProblem",
+    "AfterLibraryCallbackProblem",
+    "BeforeLibraryCallbackProblem",
+    "CreateConfigCategoryProblem",
+    "DependencyInstallationFailedProblem",
+    "DeprecatedNodeWarningProblem",
+    "DuplicateLibraryProblem",
+    "DuplicateNodeRegistrationProblem",
+    "EngineVersionErrorProblem",
+    "InsufficientDiskSpaceProblem",
+    "InvalidVersionStringProblem",
+    "LibraryJsonDecodeProblem",
+    "LibraryLoadExceptionProblem",
+    "LibraryNotFoundProblem",
+    "LibraryProblem",
+    "LibrarySchemaExceptionProblem",
+    "LibrarySchemaValidationProblem",
+    "ModifiedParametersSetDeprecationWarningProblem",
+    "ModifiedParametersSetRemovedProblem",
+    "NodeClassNotBaseNodeProblem",
+    "NodeClassNotFoundProblem",
+    "NodeModuleImportProblem",
+    "SandboxDirectoryMissingProblem",
+    "UiOptionsFieldModifiedIncompatibleProblem",
+    "UiOptionsFieldModifiedWarningProblem",
+    "UpdateConfigCategoryProblem",
+    "VenvCreationFailedProblem",
+]

griptape_nodes/retained_mode/managers/fitness_problems/libraries/advanced_library_load_failure_problem.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AdvancedLibraryLoadFailureProblem(LibraryProblem):
+    """Problem indicating an advanced library module failed to load."""
+
+    advanced_library_path: str
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[AdvancedLibraryLoadFailureProblem]) -> str:
+        """Display advanced library load failure problem.
+
+        There should only be one instance per library since each LibraryInfo
+        is already associated with a specific library path.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "AdvancedLibraryLoadFailureProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one AdvancedLibraryLoadFailureProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's details
+        problem = instances[0]
+        return f"Failed to load Advanced Library module from '{problem.advanced_library_path}': {problem.error_message}"

griptape_nodes/retained_mode/managers/fitness_problems/libraries/after_library_callback_problem.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from griptape_nodes.retained_mode.managers.fitness_problems.libraries.library_problem import LibraryProblem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AfterLibraryCallbackProblem(LibraryProblem):
+    """Problem indicating an error calling the after_library_nodes_loaded callback."""
+
+    error_message: str
+
+    @classmethod
+    def collate_problems_for_display(cls, instances: list[AfterLibraryCallbackProblem]) -> str:
+        """Display after library callback problem.
+
+        There should only be one instance per library since there's only one
+        after_library_nodes_loaded callback per library.
+        """
+        if len(instances) > 1:
+            logger.error(
+                "AfterLibraryCallbackProblem: Expected 1 instance but got %s. Each LibraryInfo should only have one AfterLibraryCallbackProblem.",
+                len(instances),
+            )
+
+        # Use the first instance's error message
+        error_msg = instances[0].error_message
+        return f"Error calling after_library_nodes_loaded callback: {error_msg}"