griptape-nodes 0.62.2__tar.gz → 0.62.3__tar.gz

{griptape_nodes-0.62.2 → griptape_nodes-0.62.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.62.2
+Version: 0.62.3
 Summary: Add your description here
 Requires-Dist: griptape>=1.8.12
 Requires-Dist: pydantic>=2.10.6

{griptape_nodes-0.62.2 → griptape_nodes-0.62.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.62.2"
+version = "0.62.3"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"

{griptape_nodes-0.62.2 → griptape_nodes-0.62.3}/src/griptape_nodes/retained_mode/events/app_events.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass, field
+from enum import StrEnum
 
 from griptape_nodes.retained_mode.events.base_events import (
     AppPayload,
@@ -11,6 +12,21 @@ from griptape_nodes.retained_mode.events.base_events import (
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
 
+class InitializationPhase(StrEnum):
+    """Initialization phase types for engine startup."""
+
+    LIBRARIES = "libraries"
+    WORKFLOWS = "workflows"
+
+
+class InitializationStatus(StrEnum):
+    """Status types for initialization progress."""
+
+    LOADING = "loading"
+    COMPLETE = "complete"
+    FAILED = "failed"
+
+
 @dataclass
 class OrganizationInfo:
     """Organization information from Griptape Cloud."""
@@ -104,6 +120,28 @@ class AppConnectionEstablished(AppPayload):
     """Notification that a connection to the API has been established."""
 
 
+@dataclass
+@PayloadRegistry.register
+class EngineInitializationProgress(AppPayload):
+    """Real-time progress updates during engine initialization (libraries and workflows loading).
+
+    Args:
+        phase: Current initialization phase (libraries or workflows)
+        item_name: Name of the library or workflow being loaded
+        status: Current status of the item (loading, complete, or failed)
+        current: Number of items completed so far
+        total: Total number of items to load
+        error: Error message if status is failed, None otherwise
+    """
+
+    phase: InitializationPhase
+    item_name: str
+    status: InitializationStatus
+    current: int
+    total: int
+    error: str | None = None
+
+
 @dataclass
 @PayloadRegistry.register
 class GetEngineVersionRequest(RequestPayload):

{griptape_nodes-0.62.2 → griptape_nodes-0.62.3}/src/griptape_nodes/retained_mode/managers/library_manager.py

@@ -36,12 +36,15 @@ from griptape_nodes.node_library.library_registry import (
 )
 from griptape_nodes.retained_mode.events.app_events import (
     AppInitializationComplete,
+    EngineInitializationProgress,
     GetEngineVersionRequest,
     GetEngineVersionResultSuccess,
+    InitializationPhase,
+    InitializationStatus,
 )
 
 # Runtime imports for ResultDetails since it's used at runtime
-from griptape_nodes.retained_mode.events.base_events import ResultDetails
+from griptape_nodes.retained_mode.events.base_events import AppEvent, ResultDetails
 from griptape_nodes.retained_mode.events.config_events import (
     GetConfigCategoryRequest,
     GetConfigCategoryResultSuccess,
@@ -1532,13 +1535,44 @@ class LibraryManager:
                     problems=failed_library.problems,
                 )
 
+            # Calculate total libraries for progress tracking
+            total_libraries = len(metadata_result.successful_libraries)
+
             # Use metadata results to selectively load libraries
-            for library_result in metadata_result.successful_libraries:
+            for current_library_index, library_result in enumerate(metadata_result.successful_libraries, start=1):
+                library_name = library_result.library_schema.name
+
+                # Emit loading event
+                GriptapeNodes.EventManager().put_event(
+                    AppEvent(
+                        payload=EngineInitializationProgress(
+                            phase=InitializationPhase.LIBRARIES,
+                            item_name=library_name,
+                            status=InitializationStatus.LOADING,
+                            current=current_library_index,
+                            total=total_libraries,
+                        )
+                    )
+                )
+
+                # Register the library
                 if library_result.library_schema.name == LibraryManager.SANDBOX_LIBRARY_NAME:
                     # Handle sandbox library - use the schema we already have
                     await self._attempt_generate_sandbox_library_from_schema(
                         library_schema=library_result.library_schema, sandbox_directory=library_result.file_path
                     )
+                    # Emit success event for sandbox library
+                    GriptapeNodes.EventManager().put_event(
+                        AppEvent(
+                            payload=EngineInitializationProgress(
+                                phase=InitializationPhase.LIBRARIES,
+                                item_name=library_name,
+                                status=InitializationStatus.COMPLETE,
+                                current=current_library_index,
+                                total=total_libraries,
+                            )
+                        )
+                    )
                 else:
                     # Handle config-based library - register it directly using the file path
                     register_request = RegisterLibraryFromFileRequest(
@@ -1549,6 +1583,37 @@ class LibraryManager:
                         # Registration failed - the failure info is already recorded in _library_file_path_to_info
                         # by register_library_from_file_request, so we just log it here for visibility
                         logger.warning("Failed to register library from %s", library_result.file_path)
+                        # Emit failure event
+                        error_message = (
+                            register_result.result_details.result_details[0].message
+                            if isinstance(register_result.result_details, ResultDetails)
+                            else register_result.result_details
+                        )
+                        GriptapeNodes.EventManager().put_event(
+                            AppEvent(
+                                payload=EngineInitializationProgress(
+                                    phase=InitializationPhase.LIBRARIES,
+                                    item_name=library_name,
+                                    status=InitializationStatus.FAILED,
+                                    current=current_library_index,
+                                    total=total_libraries,
+                                    error=error_message,
+                                )
+                            )
+                        )
+                    else:
+                        # Emit success event
+                        GriptapeNodes.EventManager().put_event(
+                            AppEvent(
+                                payload=EngineInitializationProgress(
+                                    phase=InitializationPhase.LIBRARIES,
+                                    item_name=library_name,
+                                    status=InitializationStatus.COMPLETE,
+                                    current=current_library_index,
+                                    total=total_libraries,
+                                )
+                            )
+                        )
 
             # Print 'em all pretty
             self.print_library_load_status()

{griptape_nodes-0.62.2 → griptape_nodes-0.62.3}/src/griptape_nodes/retained_mode/managers/workflow_manager.py

@@ -32,12 +32,15 @@ from griptape_nodes.node_library.workflow_registry import (
     WorkflowShape,
 )
 from griptape_nodes.retained_mode.events.app_events import (
+    EngineInitializationProgress,
     GetEngineVersionRequest,
     GetEngineVersionResultSuccess,
+    InitializationPhase,
+    InitializationStatus,
 )
 
 # Runtime imports for ResultDetails since it's used at runtime
-from griptape_nodes.retained_mode.events.base_events import ResultDetail, ResultDetails
+from griptape_nodes.retained_mode.events.base_events import AppEvent, ResultDetail, ResultDetails
 from griptape_nodes.retained_mode.events.flow_events import (
     CreateFlowRequest,
     GetTopLevelFlowRequest,
@@ -4097,40 +4100,98 @@ class WorkflowManager:
         Returns:
             WorkflowRegistrationResult with succeeded and failed workflow names
         """
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
         succeeded = []
         failed = []
 
-        def process_workflow_file(workflow_file: Path) -> None:
-            """Process a single workflow file for registration."""
-            # Check if the file has workflow metadata before processing
-            metadata_blocks = self.get_workflow_metadata(
-                workflow_file, block_name=WorkflowManager.WORKFLOW_METADATA_HEADER
-            )
-            if len(metadata_blocks) == 1:
-                workflow_name = self._process_single_workflow_file(workflow_file)
-                if workflow_name:
-                    succeeded.append(workflow_name)
-                else:
-                    failed.append(str(workflow_file))
+        # First pass: collect all workflow files to determine total count
+        all_workflow_files: list[Path] = []
 
-        def process_path(path: Path) -> None:
-            """Process a path, handling both files and directories."""
+        def collect_workflow_files(path: Path) -> None:
+            """Collect workflow files from a path."""
             if not path.exists():
-                failed.append(str(path))
                 return
             if path.is_dir():
-                # Process all Python files recursively in the directory
-                # Exclude .venv directories to avoid encoding issues with test files
                 for workflow_file in path.rglob("*.py"):
-                    # Skip files in .venv directories
                     if ".venv" in workflow_file.parts:
                         continue
-                    process_workflow_file(workflow_file)
+                    # Check if file has workflow metadata
+                    try:
+                        metadata_blocks = self.get_workflow_metadata(
+                            workflow_file, block_name=WorkflowManager.WORKFLOW_METADATA_HEADER
+                        )
+                        if len(metadata_blocks) == 1:
+                            all_workflow_files.append(workflow_file)
+                    except Exception as e:
+                        # Skip files that can't be read or parsed
+                        logger.debug("Skipping workflow file %s due to error: %s", workflow_file, e)
+                        continue
             elif path.suffix == ".py":
-                process_workflow_file(path)
+                try:
+                    metadata_blocks = self.get_workflow_metadata(
+                        path, block_name=WorkflowManager.WORKFLOW_METADATA_HEADER
+                    )
+                    if len(metadata_blocks) == 1:
+                        all_workflow_files.append(path)
+                except Exception as e:
+                    logger.debug("Skipping workflow file %s due to error: %s", path, e)
 
+        # Collect all workflow files first
         for workflow_to_register in workflows_to_register:
-            process_path(Path(workflow_to_register))
+            collect_workflow_files(Path(workflow_to_register))
+
+        # Track progress
+        total_workflows = len(all_workflow_files)
+
+        # Second pass: process each workflow file with progress events
+        for current_index, workflow_file in enumerate(all_workflow_files, start=1):
+            workflow_name = str(workflow_file.name)
+
+            # Emit loading event
+            GriptapeNodes.EventManager().put_event(
+                AppEvent(
+                    payload=EngineInitializationProgress(
+                        phase=InitializationPhase.WORKFLOWS,
+                        item_name=workflow_name,
+                        status=InitializationStatus.LOADING,
+                        current=current_index,
+                        total=total_workflows,
+                    )
+                )
+            )
+
+            # Process the workflow
+            result_name = self._process_single_workflow_file(workflow_file)
+            if result_name:
+                succeeded.append(result_name)
+                # Emit success event
+                GriptapeNodes.EventManager().put_event(
+                    AppEvent(
+                        payload=EngineInitializationProgress(
+                            phase=InitializationPhase.WORKFLOWS,
+                            item_name=workflow_name,
+                            status=InitializationStatus.COMPLETE,
+                            current=current_index,
+                            total=total_workflows,
+                        )
+                    )
+                )
+            else:
+                failed.append(str(workflow_file))
+                # Emit failure event
+                GriptapeNodes.EventManager().put_event(
+                    AppEvent(
+                        payload=EngineInitializationProgress(
+                            phase=InitializationPhase.WORKFLOWS,
+                            item_name=workflow_name,
+                            status=InitializationStatus.FAILED,
+                            current=current_index,
+                            total=total_workflows,
+                            error="Failed to process workflow file",
+                        )
+                    )
+                )
 
         return WorkflowRegistrationResult(succeeded=succeeded, failed=failed)