griptape-nodes 0.38.1__py3-none-any.whl → 0.41.0__py3-none-any.whl

griptape_nodes/retained_mode/events/app_events.py

@@ -13,7 +13,8 @@ from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 @dataclass
 @PayloadRegistry.register
 class AppStartSessionRequest(RequestPayload):
-    session_id: str
+    # TODO: https://github.com/griptape-ai/griptape-nodes/issues/1600
+    session_id: str | None = None
 
 
 @dataclass
@@ -68,5 +69,115 @@ class GetEngineVersionResultSuccess(ResultPayloadSuccess):
 
 @dataclass
 @PayloadRegistry.register
-class GetEngineVersionResultFailure(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+class GetEngineVersionResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class AppEndSessionRequest(RequestPayload):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class AppEndSessionResultSuccess(ResultPayloadSuccess):
+    session_id: str | None
+
+
+@dataclass
+@PayloadRegistry.register
+class AppEndSessionResultFailure(ResultPayloadFailure):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class SessionHeartbeatRequest(RequestPayload):
+    """Request clients can use ensure the engine session is still active."""
+
+
+@dataclass
+@PayloadRegistry.register
+class SessionHeartbeatResultSuccess(ResultPayloadSuccess):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class SessionHeartbeatResultFailure(ResultPayloadFailure):
     pass
+
+
+@dataclass
+@PayloadRegistry.register
+class EngineHeartbeatRequest(RequestPayload):
+    """Request clients can use to discover active engines and their status.
+
+    Attributes:
+        heartbeat_id: Unique identifier for the heartbeat request, used to correlate requests and responses.
+
+    """
+
+    heartbeat_id: str
+
+
+@dataclass
+@PayloadRegistry.register
+class EngineHeartbeatResultSuccess(ResultPayloadSuccess):
+    heartbeat_id: str
+    engine_version: str
+    engine_id: str | None
+    session_id: str | None
+    timestamp: str
+    instance_type: str | None
+    instance_region: str | None
+    instance_provider: str | None
+    deployment_type: str | None
+    public_ip: str | None
+    current_workflow: str | None
+    workflow_file_path: str | None
+    has_active_flow: bool
+    engine_name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class EngineHeartbeatResultFailure(ResultPayloadFailure):
+    heartbeat_id: str
+
+
+@dataclass
+@PayloadRegistry.register
+class SetEngineNameRequest(RequestPayload):
+    engine_name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class SetEngineNameResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    engine_name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class SetEngineNameResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    error_message: str
+
+
+@dataclass
+@PayloadRegistry.register
+class GetEngineNameRequest(RequestPayload):
+    pass
+
+
+@dataclass
+@PayloadRegistry.register
+class GetEngineNameResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    engine_name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class GetEngineNameResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    error_message: str

griptape_nodes/retained_mode/events/base_events.py

@@ -12,6 +12,9 @@ from griptape.structures import Structure
 from griptape.tools import BaseTool
 from pydantic import BaseModel, Field
 
+from griptape_nodes.retained_mode.utils.engine_identity import EngineIdentity
+from griptape_nodes.retained_mode.utils.session_persistence import SessionPersistence
+
 if TYPE_CHECKING:
     import builtins
 
@@ -28,6 +31,7 @@ class RequestPayload(Payload, ABC):
 
 
 # Result payload base class with abstract succeeded/failed methods, and indicator whether the current workflow was altered.
+@dataclass(kw_only=True)
 class ResultPayload(Payload, ABC):
     """Base class for all result payloads."""
 
@@ -62,6 +66,7 @@ class WorkflowNotAlteredMixin:
 
 
 # Success result payload abstract base class
+@dataclass(kw_only=True)
 class ResultPayloadSuccess(ResultPayload, ABC):
     """Abstract base class for success result payloads."""
 
@@ -75,9 +80,12 @@ class ResultPayloadSuccess(ResultPayload, ABC):
 
 
 # Failure result payload abstract base class
+@dataclass(kw_only=True)
 class ResultPayloadFailure(ResultPayload, ABC):
     """Abstract base class for failure result payloads."""
 
+    exception: Exception | None = None
+
     def succeeded(self) -> bool:
         """Returns False as this is a failure result.
 
@@ -108,10 +116,29 @@ class BaseEvent(BaseModel, ABC):
     # Keeping here instead of in GriptapeNodes to avoid circular import hell.
     # TODO: https://github.com/griptape-ai/griptape-nodes/issues/848
     _session_id: ClassVar[str | None] = None
+    _engine_id: ClassVar[str | None] = None
 
-    # Instance variable with a default_factory that references the class variable
+    # Instance variables with a default_factory that references the class variable
+    engine_id: str | None = Field(default_factory=lambda: BaseEvent._engine_id)
     session_id: str | None = Field(default_factory=lambda: BaseEvent._session_id)
 
+    @classmethod
+    def initialize_engine_id(cls) -> None:
+        """Initialize the engine ID if not already set."""
+        if cls._engine_id is None:
+            persisted_engine_id = cls._engine_id = EngineIdentity.get_engine_id()
+            if persisted_engine_id:
+                cls._engine_id = persisted_engine_id
+
+    @classmethod
+    def initialize_session_id(cls) -> None:
+        """Initialize the session ID from persisted storage if available."""
+        if cls._session_id is None:
+            # Check if there's a persisted session ID
+            persisted_session_id = SessionPersistence.get_persisted_session_id()
+            if persisted_session_id:
+                cls._session_id = persisted_session_id
+
     # Custom JSON encoder for the payload
     class Config:
         """Pydantic configuration for the BaseEvent class."""

griptape_nodes/retained_mode/events/library_events.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from griptape_nodes.node_library.library_registry import LibraryMetadata, NodeMetadata
 from griptape_nodes.retained_mode.events.base_events import (
     RequestPayload,
     ResultPayloadFailure,
@@ -10,6 +12,10 @@ from griptape_nodes.retained_mode.events.base_events import (
 )
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
+if TYPE_CHECKING:
+    from griptape_nodes.node_library.library_registry import LibraryMetadata, LibrarySchema, NodeMetadata
+    from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
+
 
 @dataclass
 @PayloadRegistry.register
@@ -66,6 +72,110 @@ class GetNodeMetadataFromLibraryResultFailure(WorkflowNotAlteredMixin, ResultPay
     pass
 
 
+@dataclass
+@PayloadRegistry.register
+class LoadLibraryMetadataFromFileRequest(RequestPayload):
+    """Request to load library metadata from a JSON file without loading node modules.
+
+    This provides a lightweight way to get library schema information without the overhead
+    of dynamically importing Python modules. Useful for metadata queries, validation,
+    and library discovery operations.
+
+    Args:
+        file_path: Absolute path to the library JSON schema file to load.
+    """
+
+    file_path: str
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadLibraryMetadataFromFileResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Successful result from loading library metadata.
+
+    Contains the validated library schema that can be used for metadata queries,
+    node type discovery, and other operations that don't require the actual
+    node classes to be loaded.
+
+    Args:
+        library_schema: The validated LibrarySchema object containing all metadata
+                       about the library including nodes, categories, and settings.
+        file_path: The file path from which the library metadata was loaded.
+    """
+
+    library_schema: LibrarySchema
+    file_path: str
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadLibraryMetadataFromFileResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failed result from loading library metadata with detailed error information.
+
+    Provides comprehensive error details including the specific failure type and
+    a list of problems encountered during loading. This allows callers to understand
+    exactly what went wrong and take appropriate action.
+
+    Args:
+        library_path: Path to the library file that failed to load.
+        library_name: Name of the library if it could be extracted from the JSON,
+                     None if the name couldn't be determined.
+        status: The LibraryStatus enum indicating the type of failure
+               (MISSING, UNUSABLE, etc.).
+        problems: List of specific error messages describing what went wrong
+                 during loading (JSON parse errors, validation failures, etc.).
+    """
+
+    library_path: str
+    library_name: str | None
+    status: LibraryManager.LibraryStatus
+    problems: list[str]
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadMetadataForAllLibrariesRequest(RequestPayload):
+    """Request to load metadata for all libraries from configuration without loading node modules.
+
+    This loads metadata from both:
+    1. Library JSON files specified in configuration
+    2. Sandbox library (dynamically generated from Python files)
+
+    Provides a lightweight way to discover all available libraries and their schemas
+    without the overhead of importing Python modules or registering them in the system.
+    """
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadMetadataForAllLibrariesResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Successful result from loading metadata for all libraries.
+
+    Contains metadata for all discoverable libraries from both configuration files
+    and sandbox directory, with clear separation between successful loads and failures.
+
+    Args:
+        successful_libraries: List of successful library metadata loading results,
+                             including both config-based libraries and sandbox library if applicable.
+        failed_libraries: List of detailed failure results for libraries that couldn't be loaded,
+                         including both config-based libraries and sandbox library if applicable.
+    """
+
+    successful_libraries: list[LoadLibraryMetadataFromFileResultSuccess]
+    failed_libraries: list[LoadLibraryMetadataFromFileResultFailure]
+
+
+@dataclass
+@PayloadRegistry.register
+class LoadMetadataForAllLibrariesResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failed result from loading metadata for all libraries.
+
+    This indicates a systemic failure (e.g., configuration access issues)
+    rather than individual library loading failures, which are captured
+    in the success result's failed_libraries list.
+    """
+
+
 @dataclass
 @PayloadRegistry.register
 class RegisterLibraryFromFileRequest(RequestPayload):

griptape_nodes/retained_mode/events/node_events.py

@@ -408,6 +408,7 @@ class DeserializeNodeFromCommandsResultFailure(ResultPayloadFailure):
 @PayloadRegistry.register
 class DuplicateSelectedNodesRequest(WorkflowNotAlteredMixin, RequestPayload):
     nodes_to_duplicate: list[list[str]]
+    positions: list[NewPosition] | None = None
 
 
 @dataclass

griptape_nodes/retained_mode/events/workflow_events.py

@@ -144,6 +144,7 @@ class RenameWorkflowResultFailure(ResultPayloadFailure):
 @PayloadRegistry.register
 class SaveWorkflowRequest(RequestPayload):
     file_name: str | None = None
+    image_path: str | None = None
 
 
 @dataclass

griptape_nodes/retained_mode/griptape_nodes.py

@@ -2,27 +2,48 @@ from __future__ import annotations
 
 import importlib.metadata
 import logging
+import os
 import re
+import uuid
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from typing import IO, TYPE_CHECKING, Any, TextIO
 
+import httpx
+
 from griptape_nodes.exe_types.core_types import BaseNodeElement, Parameter, ParameterContainer, ParameterGroup
 from griptape_nodes.exe_types.flow import ControlFlow
+from griptape_nodes.node_library.workflow_registry import WorkflowRegistry
 from griptape_nodes.retained_mode.events.app_events import (
+    AppEndSessionRequest,
+    AppEndSessionResultFailure,
+    AppEndSessionResultSuccess,
     AppGetSessionRequest,
     AppGetSessionResultSuccess,
     AppStartSessionRequest,
     AppStartSessionResultSuccess,
+    EngineHeartbeatRequest,
+    EngineHeartbeatResultFailure,
+    EngineHeartbeatResultSuccess,
+    GetEngineNameRequest,
+    GetEngineNameResultFailure,
+    GetEngineNameResultSuccess,
     GetEngineVersionRequest,
     GetEngineVersionResultFailure,
     GetEngineVersionResultSuccess,
+    SessionHeartbeatRequest,
+    SessionHeartbeatResultFailure,
+    SessionHeartbeatResultSuccess,
+    SetEngineNameRequest,
+    SetEngineNameResultFailure,
+    SetEngineNameResultSuccess,
 )
 from griptape_nodes.retained_mode.events.base_events import (
     AppPayload,
     BaseEvent,
     RequestPayload,
     ResultPayload,
+    ResultPayloadFailure,
 )
 from griptape_nodes.retained_mode.events.connection_events import (
     CreateConnectionRequest,
@@ -35,6 +56,8 @@ from griptape_nodes.retained_mode.events.parameter_events import (
     AddParameterToNodeRequest,
     AlterParameterDetailsRequest,
 )
+from griptape_nodes.retained_mode.utils.engine_identity import EngineIdentity
+from griptape_nodes.retained_mode.utils.session_persistence import SessionPersistence
 from griptape_nodes.utils.metaclasses import SingletonMeta
 
 if TYPE_CHECKING:
@@ -169,7 +192,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._static_files_manager = StaticFilesManager(
                 self._config_manager, self._secrets_manager, self._event_manager
             )
-            self._agent_manager = AgentManager(self._event_manager)
+            self._agent_manager = AgentManager(self._static_files_manager, self._event_manager)
             self._version_compatibility_manager = VersionCompatibilityManager(self._event_manager)
 
             # Assign handlers now that these are created.
@@ -179,7 +202,20 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._event_manager.assign_manager_to_request_type(
                 AppStartSessionRequest, self.handle_session_start_request
             )
+            self._event_manager.assign_manager_to_request_type(AppEndSessionRequest, self.handle_session_end_request)
             self._event_manager.assign_manager_to_request_type(AppGetSessionRequest, self.handle_get_session_request)
+            self._event_manager.assign_manager_to_request_type(
+                SessionHeartbeatRequest, self.handle_session_heartbeat_request
+            )
+            self._event_manager.assign_manager_to_request_type(
+                EngineHeartbeatRequest, self.handle_engine_heartbeat_request
+            )
+            self._event_manager.assign_manager_to_request_type(
+                GetEngineNameRequest, self.handle_get_engine_name_request
+            )
+            self._event_manager.assign_manager_to_request_type(
+                SetEngineNameRequest, self.handle_set_engine_name_request
+            )
 
     @classmethod
     def get_instance(cls) -> GriptapeNodes:
@@ -191,11 +227,20 @@ class GriptapeNodes(metaclass=SingletonMeta):
         event_mgr = GriptapeNodes.EventManager()
         obj_depth_mgr = GriptapeNodes.OperationDepthManager()
         workflow_mgr = GriptapeNodes.WorkflowManager()
-        return event_mgr.handle_request(
-            request=request,
-            operation_depth_mgr=obj_depth_mgr,
-            workflow_mgr=workflow_mgr,
-        )
+
+        try:
+            return event_mgr.handle_request(
+                request=request,
+                operation_depth_mgr=obj_depth_mgr,
+                workflow_mgr=workflow_mgr,
+            )
+        except Exception as e:
+            logger.exception(
+                "Unhandled exception while processing request of type %s. "
+                "Consider saving your work and restarting the engine if issues persist.",
+                type(request).__name__,
+            )
+            return ResultPayloadFailure(exception=e)
 
     @classmethod
     def broadcast_app_event(cls, app_event: AppPayload) -> None:
@@ -302,26 +347,203 @@ class GriptapeNodes(metaclass=SingletonMeta):
             logger.error(details)
             return GetEngineVersionResultFailure()
 
-    def handle_session_start_request(self, request: AppStartSessionRequest) -> ResultPayload:
-        if BaseEvent._session_id is None:
-            details = f"Session '{request.session_id}' started at {datetime.now(tz=UTC)}."
-        else:
-            if BaseEvent._session_id == request.session_id:
-                details = f"Session '{request.session_id}' already in place. No action taken."
-            else:
-                details = f"Attempted to start a session with ID '{request.session_id}' but this engine instance already had a session ID `{BaseEvent._session_id}' in place. Replacing it."
-
+    def handle_session_start_request(self, request: AppStartSessionRequest) -> ResultPayload:  # noqa: ARG002
+        current_session_id = BaseEvent._session_id
+        if current_session_id is None:
+            # Client wants a new session
+            current_session_id = uuid.uuid4().hex
+            BaseEvent._session_id = current_session_id
+            # Persist the session ID to XDG state directory
+            SessionPersistence.persist_session(current_session_id)
+            details = f"New session '{current_session_id}' started at {datetime.now(tz=UTC)}."
             logger.info(details)
+        else:
+            details = f"Session '{current_session_id}' already active. Joining..."
 
-        BaseEvent._session_id = request.session_id
+        return AppStartSessionResultSuccess(current_session_id)
 
-        # TODO: https://github.com/griptape-ai/griptape-nodes/issues/855
+    def handle_session_end_request(self, _: AppEndSessionRequest) -> ResultPayload:
+        try:
+            previous_session_id = BaseEvent._session_id
+            if BaseEvent._session_id is None:
+                details = "No active session to end."
+                logger.info(details)
+            else:
+                details = f"Session '{BaseEvent._session_id}' ended at {datetime.now(tz=UTC)}."
+                logger.info(details)
+                BaseEvent._session_id = None
+                # Clear the persisted session ID from XDG state directory
+                SessionPersistence.clear_persisted_session()
 
-        return AppStartSessionResultSuccess(request.session_id)
+            return AppEndSessionResultSuccess(session_id=previous_session_id)
+        except Exception as err:
+            details = f"Failed to end session due to '{err}'."
+            logger.error(details)
+            return AppEndSessionResultFailure()
 
     def handle_get_session_request(self, _: AppGetSessionRequest) -> ResultPayload:
         return AppGetSessionResultSuccess(session_id=BaseEvent._session_id)
 
+    def handle_session_heartbeat_request(self, request: SessionHeartbeatRequest) -> ResultPayload:  # noqa: ARG002
+        """Handle session heartbeat requests.
+
+        Simply verifies that the session is active and responds with success.
+        """
+        try:
+            if BaseEvent._session_id is None:
+                logger.warning("Session heartbeat received but no active session found")
+                return SessionHeartbeatResultFailure()
+
+            logger.debug("Session heartbeat successful for session: %s", BaseEvent._session_id)
+            return SessionHeartbeatResultSuccess()
+        except Exception as err:
+            logger.error("Failed to handle session heartbeat: %s", err)
+            return SessionHeartbeatResultFailure()
+
+    def handle_engine_heartbeat_request(self, request: EngineHeartbeatRequest) -> ResultPayload:
+        """Handle engine heartbeat requests.
+
+        Returns engine status information including version, session state, and system metrics.
+        """
+        try:
+            # Get instance information based on environment variables
+            instance_info = self._get_instance_info()
+
+            # Get current workflow information
+            workflow_info = self._get_current_workflow_info()
+
+            # Get engine name
+            engine_name = EngineIdentity.get_engine_name()
+
+            logger.debug("Engine heartbeat successful")
+            return EngineHeartbeatResultSuccess(
+                heartbeat_id=request.heartbeat_id,
+                engine_version=engine_version,
+                engine_name=engine_name,
+                engine_id=BaseEvent._engine_id,
+                session_id=BaseEvent._session_id,
+                timestamp=datetime.now(tz=UTC).isoformat(),
+                **instance_info,
+                **workflow_info,
+            )
+        except Exception as err:
+            logger.error("Failed to handle engine heartbeat: %s", err)
+            return EngineHeartbeatResultFailure(heartbeat_id=request.heartbeat_id)
+
+    def handle_get_engine_name_request(self, request: GetEngineNameRequest) -> ResultPayload:  # noqa: ARG002
+        """Handle requests to get the current engine name."""
+        try:
+            engine_name = EngineIdentity.get_engine_name()
+            logger.debug("Retrieved engine name: %s", engine_name)
+            return GetEngineNameResultSuccess(engine_name=engine_name)
+        except Exception as err:
+            error_message = f"Failed to get engine name: {err}"
+            logger.error(error_message)
+            return GetEngineNameResultFailure(error_message=error_message)
+
+    def handle_set_engine_name_request(self, request: SetEngineNameRequest) -> ResultPayload:
+        """Handle requests to set a new engine name."""
+        try:
+            # Validate engine name (basic validation)
+            if not request.engine_name or not request.engine_name.strip():
+                error_message = "Engine name cannot be empty"
+                logger.warning(error_message)
+                return SetEngineNameResultFailure(error_message=error_message)
+
+            # Set the new engine name
+            EngineIdentity.set_engine_name(request.engine_name.strip())
+            logger.info("Engine name set to: %s", request.engine_name.strip())
+            return SetEngineNameResultSuccess(engine_name=request.engine_name.strip())
+
+        except Exception as err:
+            error_message = f"Failed to set engine name: {err}"
+            logger.error(error_message)
+            return SetEngineNameResultFailure(error_message=error_message)
+
+    def _get_instance_info(self) -> dict[str, str | None]:
+        """Get instance information from environment variables.
+
+        Returns instance type, region, provider, and public IP information if available.
+        """
+        instance_info: dict[str, str | None] = {
+            "instance_type": os.getenv("GTN_INSTANCE_TYPE"),
+            "instance_region": os.getenv("GTN_INSTANCE_REGION"),
+            "instance_provider": os.getenv("GTN_INSTANCE_PROVIDER"),
+        }
+
+        # Determine deployment type based on presence of instance environment variables
+        instance_info["deployment_type"] = "griptape_hosted" if any(instance_info.values()) else "local"
+
+        # Get public IP address
+        public_ip = self._get_public_ip()
+        if public_ip:
+            instance_info["public_ip"] = public_ip
+
+        return instance_info
+
+    def _get_public_ip(self) -> str | None:
+        """Get the public IP address of this device.
+
+        Returns the public IP address if available, None otherwise.
+        """
+        try:
+            # Try multiple services in case one is down
+            services = [
+                "https://api.ipify.org",
+                "https://ipinfo.io/ip",
+                "https://icanhazip.com",
+            ]
+
+            for service in services:
+                try:
+                    with httpx.Client(timeout=5.0) as client:
+                        response = client.get(service)
+                        response.raise_for_status()
+                        public_ip = response.text.strip()
+                        if public_ip:
+                            logger.debug("Retrieved public IP from %s: %s", service, public_ip)
+                            return public_ip
+                except Exception as err:
+                    logger.debug("Failed to get public IP from %s: %s", service, err)
+                    continue
+            logger.warning("Unable to retrieve public IP from any service")
+        except Exception as err:
+            logger.warning("Failed to get public IP: %s", err)
+            return None
+        else:
+            return None
+
+    def _get_current_workflow_info(self) -> dict[str, Any]:
+        """Get information about the currently loaded workflow.
+
+        Returns workflow name, file path, and status information if available.
+        """
+        workflow_info = {
+            "current_workflow": None,
+            "workflow_file_path": None,
+            "has_active_flow": False,
+        }
+
+        try:
+            context_manager = self._context_manager
+
+            # Check if there's an active workflow
+            if context_manager.has_current_workflow():
+                workflow_name = context_manager.get_current_workflow_name()
+                workflow_info["current_workflow"] = workflow_name
+                workflow_info["has_active_flow"] = context_manager.has_current_flow()
+
+                # Get workflow file path from registry
+                if WorkflowRegistry.has_workflow_with_name(workflow_name):
+                    workflow = WorkflowRegistry.get_workflow_by_name(workflow_name)
+                    absolute_path = WorkflowRegistry.get_complete_file_path(workflow.file_path)
+                    workflow_info["workflow_file_path"] = absolute_path
+
+        except Exception as err:
+            logger.warning("Failed to get current workflow info: %s", err)
+
+        return workflow_info
+
 
 def create_flows_in_order(flow_name: str, flow_manager: FlowManager, created_flows: list, file: IO) -> list | None:
     """Creates flows in the correct order based on their dependencies."""