griptape-nodes 0.52.1__py3-none-any.whl → 0.54.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/object_manager.py

@@ -10,6 +10,7 @@ from griptape_nodes.exe_types.core_types import (
 from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.exe_types.node_types import BaseNode
 from griptape_nodes.retained_mode.events.base_events import (
+    ResultDetails,
     ResultPayload,
 )
 from griptape_nodes.retained_mode.events.execution_events import (
@@ -50,7 +51,10 @@ class ObjectManager:
     def on_rename_object_request(self, request: RenameObjectRequest) -> ResultPayload:
         # Does the source object exist?
         if request.object_name == request.requested_name:
-            return RenameObjectResultSuccess(final_name=request.requested_name)
+            return RenameObjectResultSuccess(
+                final_name=request.requested_name,
+                result_details=f"Object '{request.requested_name}' already has the requested name",
+            )
         source_obj = self.attempt_get_object_by_name(request.object_name)
         if source_obj is None:
             details = f"Attempted to rename object '{request.object_name}', but no object of that name could be found."
@@ -97,8 +101,11 @@ class ObjectManager:
         if final_name != request.requested_name:
             details += " WARNING: Originally requested the name '{request.requested_name}', but that was taken."
             log_level = logging.WARNING
-        logger.log(level=log_level, msg=details)
-        return RenameObjectResultSuccess(final_name=final_name)
+        if log_level == logging.WARNING:
+            result_details = ResultDetails(message=details, level=logging.WARNING)
+        else:
+            result_details = details
+        return RenameObjectResultSuccess(final_name=final_name, result_details=result_details)
 
     def on_clear_all_object_state_request(self, request: ClearAllObjectStateRequest) -> ResultPayload:  # noqa: C901
         if not request.i_know_what_im_doing:
@@ -148,8 +155,7 @@ class ObjectManager:
         GriptapeNodes.VariablesManager().on_clear_object_state()
 
         details = "Successfully cleared all object state (deleted everything)."
-        logger.debug(details)
-        return ClearAllObjectStateResultSuccess()
+        return ClearAllObjectStateResultSuccess(result_details=details)
 
     def get_filtered_subset[T](
         self,

griptape_nodes/retained_mode/managers/os_manager.py

@@ -1,4 +1,5 @@
 import base64
+import logging
 import mimetypes
 import os
 import shutil
@@ -11,7 +12,7 @@ from typing import Any
 from binaryornot.check import is_binary
 from rich.console import Console
 
-from griptape_nodes.retained_mode.events.base_events import ResultPayload
+from griptape_nodes.retained_mode.events.base_events import ResultDetails, ResultPayload
 from griptape_nodes.retained_mode.events.os_events import (
     CreateFileRequest,
     CreateFileResultFailure,
@@ -304,7 +305,7 @@ class OSManager:
                 logger.info(details)
                 return OpenAssociatedFileResultFailure(result_details=details)
 
-            return OpenAssociatedFileResultSuccess()
+            return OpenAssociatedFileResultSuccess(result_details="File opened successfully in associated application.")
         except subprocess.CalledProcessError as e:
             details = (
                 f"Process error when opening file: return code={e.returncode}, stdout={e.stdout}, stderr={e.stderr}"
@@ -399,11 +400,17 @@ class OSManager:
             if request.workspace_only:
                 # In workspace mode, return relative path if within workspace, absolute if outside
                 return ListDirectoryResultSuccess(
-                    entries=entries, current_path=str(relative_or_abs_path), is_workspace_path=is_workspace_path
+                    entries=entries,
+                    current_path=str(relative_or_abs_path),
+                    is_workspace_path=is_workspace_path,
+                    result_details="Directory listing retrieved successfully.",
                 )
             # In system-wide mode, always return the full absolute path
             return ListDirectoryResultSuccess(
-                entries=entries, current_path=str(directory), is_workspace_path=is_workspace_path
+                entries=entries,
+                current_path=str(directory),
+                is_workspace_path=is_workspace_path,
+                result_details="Directory listing retrieved successfully.",
             )
 
         except Exception as e:
@@ -430,6 +437,7 @@ class OSManager:
                 mime_type=mime_type,
                 encoding=encoding,
                 compression_encoding=compression_encoding,
+                result_details="File read successfully.",
             )
 
         except (ValueError, FileNotFoundError) as e:
@@ -509,15 +517,14 @@ class OSManager:
 
         # Check if file is already in the static files directory
         config_manager = GriptapeNodes.ConfigManager()
-        static_files_directory = config_manager.get_config_value("static_files_directory", default="staticfiles")
-        static_dir = config_manager.workspace_path / static_files_directory
+        static_dir = config_manager.workspace_path
 
         try:
             # Check if file is within the static files directory
             file_relative_to_static = file_path.relative_to(static_dir)
             # File is in static directory, construct URL directly
-            static_url = f"http://localhost:8124/static/{file_relative_to_static}"
-            msg = f"Image already in static directory, returning URL: {static_url}"
+            static_url = f"http://localhost:8124/workspace/{file_relative_to_static}"
+            msg = f"Image already in workspace directory, returning URL: {static_url}"
             logger.debug(msg)
         except ValueError:
             # File is not in static directory, create small preview
@@ -759,8 +766,9 @@ class OSManager:
             # Check if it already exists - warn but treat as success
             if file_path.exists():
                 msg = f"Path already exists: {file_path}"
-                logger.warning(msg)
-                return CreateFileResultSuccess(created_path=str(file_path))
+                return CreateFileResultSuccess(
+                    created_path=str(file_path), result_details=ResultDetails(message=msg, level=logging.WARNING)
+                )
 
             # Create parent directories if needed
             file_path.parent.mkdir(parents=True, exist_ok=True)
@@ -777,7 +785,10 @@ class OSManager:
                 file_path.touch()
                 logger.info("Created empty file: %s", file_path)
 
-            return CreateFileResultSuccess(created_path=str(file_path))
+            return CreateFileResultSuccess(
+                created_path=str(file_path),
+                result_details=f"{'Directory' if request.is_directory else 'File'} created successfully at {file_path}",
+            )
 
         except Exception as e:
             path_info = request.get_full_path() if hasattr(request, "get_full_path") else str(request.path)
@@ -820,9 +831,13 @@ class OSManager:
 
             # Perform the rename operation
             old_path.rename(new_path)
-            logger.info("Renamed: %s -> %s", old_path, new_path)
+            details = f"Renamed: {old_path} -> {new_path}"
 
-            return RenameFileResultSuccess(old_path=str(old_path), new_path=str(new_path))
+            return RenameFileResultSuccess(
+                old_path=str(old_path),
+                new_path=str(new_path),
+                result_details=ResultDetails(message=details, level=logging.INFO),
+            )
 
         except Exception as e:
             msg = f"Failed to rename {request.old_path} to {request.new_path}: {e}"

griptape_nodes/retained_mode/managers/secrets_manager.py

@@ -60,7 +60,9 @@ class SecretsManager:
             logger.error(details)
             return GetSecretValueResultFailure(result_details=details)
 
-        return GetSecretValueResultSuccess(value=secret_value)
+        return GetSecretValueResultSuccess(
+            value=secret_value, result_details=f"Successfully retrieved secret value for key: {secret_key}"
+        )
 
     def on_handle_set_secret_request(self, request: SetSecretValueRequest) -> ResultPayload:
         secret_name = SecretsManager._apply_secret_name_compliance(request.key)
@@ -77,12 +79,14 @@ class SecretsManager:
 
         self.set_secret(secret_name, secret_value)
 
-        return SetSecretValueResultSuccess()
+        return SetSecretValueResultSuccess(result_details=f"Successfully set secret value for key: {secret_name}")
 
     def on_handle_get_all_secret_values_request(self, request: GetAllSecretValuesRequest) -> ResultPayload:  # noqa: ARG002
         secret_values = dotenv_values(ENV_VAR_PATH)
 
-        return GetAllSecretValuesResultSuccess(values=secret_values)
+        return GetAllSecretValuesResultSuccess(
+            values=secret_values, result_details=f"Successfully retrieved {len(secret_values)} secret values"
+        )
 
     def on_handle_delete_secret_value_request(self, request: DeleteSecretValueRequest) -> ResultPayload:
         secret_name = SecretsManager._apply_secret_name_compliance(request.key)
@@ -101,7 +105,7 @@ class SecretsManager:
 
         logger.info("Secret '%s' deleted.", secret_name)
 
-        return DeleteSecretValueResultSuccess()
+        return DeleteSecretValueResultSuccess(result_details=f"Successfully deleted secret: {secret_name}")
 
     def get_secret(self, secret_name: str, *, should_error_on_not_found: bool = True) -> str | None:
         """Return the secret value with the following search precedence (highest to lowest priority).

griptape_nodes/retained_mode/managers/settings.py

@@ -1,12 +1,65 @@
+from enum import StrEnum
 from pathlib import Path
 from typing import Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic import Field as PydanticField
+
+
+class Category(BaseModel):
+    """A category with name and optional description."""
+
+    name: str
+    description: str | None = None
+
+    def __str__(self) -> str:
+        return self.name
+
+
+# Predefined categories to avoid repetition
+FILE_SYSTEM = Category(name="File System", description="Directories and file paths for the application")
+APPLICATION_EVENTS = Category(name="Application Events", description="Configuration for application lifecycle events")
+API_KEYS = Category(name="API Keys", description="API keys and authentication credentials")
+EXECUTION = Category(name="Execution", description="Workflow execution and processing settings")
+STORAGE = Category(name="Storage", description="Data storage and persistence configuration")
+SYSTEM_REQUIREMENTS = Category(name="System Requirements", description="System resource requirements and limits")
+
+
+def Field(category: str | Category = "General", **kwargs) -> Any:
+    """Enhanced Field with default category that can be overridden."""
+    if "json_schema_extra" not in kwargs:
+        # Convert Category to dict or use string directly
+        if isinstance(category, Category):
+            category_dict = {"name": category.name}
+            if category.description:
+                category_dict["description"] = category.description
+            kwargs["json_schema_extra"] = {"category": category_dict}
+        else:
+            kwargs["json_schema_extra"] = {"category": category}
+    return PydanticField(**kwargs)
+
+
+class WorkflowExecutionMode(StrEnum):
+    """Execution type for node processing."""
+
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"
+
+
+class LogLevel(StrEnum):
+    """Logging level for the application."""
+
+    CRITICAL = "CRITICAL"
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+    INFO = "INFO"
+    DEBUG = "DEBUG"
 
 
 class AppInitializationComplete(BaseModel):
     libraries_to_register: list[str] = Field(default_factory=list)
     workflows_to_register: list[str] = Field(default_factory=list)
+    models_to_download: list[str] = Field(default_factory=list)
 
 
 class AppEvents(BaseModel):
@@ -41,17 +94,26 @@ class AppEvents(BaseModel):
 class Settings(BaseModel):
     model_config = ConfigDict(extra="allow")
 
-    workspace_directory: str = Field(default=str(Path().cwd() / "GriptapeNodes"))
+    workspace_directory: str = Field(
+        category=FILE_SYSTEM,
+        default=str(Path().cwd() / "GriptapeNodes"),
+    )
     static_files_directory: str = Field(
+        category=FILE_SYSTEM,
         default="staticfiles",
         description="Path to the static files directory, relative to the workspace directory.",
     )
     sandbox_library_directory: str = Field(
+        category=FILE_SYSTEM,
         default="sandbox_library",
         description="Path to the sandbox library directory (useful while developing nodes). If presented as just a directory (e.g., 'sandbox_library') it will be interpreted as being relative to the workspace directory.",
     )
-    app_events: AppEvents = Field(default_factory=AppEvents)
+    app_events: AppEvents = Field(
+        category=APPLICATION_EVENTS,
+        default_factory=AppEvents,
+    )
     nodes: dict[str, Any] = Field(
+        category=API_KEYS,
         default_factory=lambda: {
             "Griptape": {"GT_CLOUD_API_KEY": "$GT_CLOUD_API_KEY"},
             "OpenAI": {"OPENAI_API_KEY": "$OPENAI_API_KEY"},
@@ -86,18 +148,65 @@ class Settings(BaseModel):
             },
             "Tavily": {"TAVILY_API_KEY": "$TAVILY_API_KEY"},
             "Serper": {"SERPER_API_KEY": "$SERPER_API_KEY"},
-        }
+        },
+    )
+    log_level: LogLevel = Field(category=EXECUTION, default=LogLevel.INFO)
+    workflow_execution_mode: WorkflowExecutionMode = Field(
+        category=EXECUTION,
+        default=WorkflowExecutionMode.SEQUENTIAL,
+        description="Workflow execution mode for node processing",
+    )
+
+    @field_validator("workflow_execution_mode", mode="before")
+    @classmethod
+    def validate_workflow_execution_mode(cls, v: Any) -> WorkflowExecutionMode:
+        """Convert string values to WorkflowExecutionMode enum."""
+        if isinstance(v, str):
+            try:
+                return WorkflowExecutionMode(v.lower())
+            except ValueError:
+                # Return default if invalid string
+                return WorkflowExecutionMode.SEQUENTIAL
+        elif isinstance(v, WorkflowExecutionMode):
+            return v
+        else:
+            # Return default for any other type
+            return WorkflowExecutionMode.SEQUENTIAL
+
+    @field_validator("log_level", mode="before")
+    @classmethod
+    def validate_log_level(cls, v: Any) -> LogLevel:
+        """Convert string values to LogLevel enum."""
+        if isinstance(v, str):
+            try:
+                return LogLevel(v.upper())
+            except ValueError:
+                # Return default if invalid string
+                return LogLevel.INFO
+        elif isinstance(v, LogLevel):
+            return v
+        else:
+            # Return default for any other type
+            return LogLevel.INFO
+
+    max_nodes_in_parallel: int | None = Field(
+        category=EXECUTION,
+        default=5,
+        description="Maximum number of nodes executing at a time for parallel execution.",
     )
-    log_level: str = Field(default="INFO")
-    storage_backend: Literal["local", "gtc"] = Field(default="local")
+    storage_backend: Literal["local", "gtc"] = Field(category=STORAGE, default="local")
     minimum_disk_space_gb_libraries: float = Field(
+        category=SYSTEM_REQUIREMENTS,
         default=10.0,
         description="Minimum disk space in GB required for library installation and virtual environment operations",
     )
     minimum_disk_space_gb_workflows: float = Field(
-        default=1.0, description="Minimum disk space in GB required for saving workflows"
+        category=SYSTEM_REQUIREMENTS,
+        default=1.0,
+        description="Minimum disk space in GB required for saving workflows",
     )
     synced_workflows_directory: str = Field(
+        category=FILE_SYSTEM,
         default="synced_workflows",
         description="Path to the synced workflows directory, relative to the workspace directory.",
     )

griptape_nodes/retained_mode/managers/static_files_manager.py

@@ -1,6 +1,8 @@
 import base64
 import binascii
 import logging
+import threading
+from pathlib import Path
 
 import httpx
 from xdg_base_dirs import xdg_config_home
@@ -8,6 +10,7 @@ from xdg_base_dirs import xdg_config_home
 from griptape_nodes.drivers.storage import StorageBackend
 from griptape_nodes.drivers.storage.griptape_cloud_storage_driver import GriptapeCloudStorageDriver
 from griptape_nodes.drivers.storage.local_storage_driver import LocalStorageDriver
+from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.static_file_events import (
     CreateStaticFileDownloadUrlRequest,
     CreateStaticFileDownloadUrlResultFailure,
@@ -22,6 +25,7 @@ from griptape_nodes.retained_mode.events.static_file_events import (
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
 from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
+from griptape_nodes.servers.static import start_static_server
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -46,9 +50,10 @@ class StaticFilesManager:
         """
         self.config_manager = config_manager
 
-        storage_backend = config_manager.get_config_value("storage_backend", default=StorageBackend.LOCAL)
+        self.storage_backend = config_manager.get_config_value("storage_backend", default=StorageBackend.LOCAL)
+        workspace_directory = Path(config_manager.get_config_value("workspace_directory"))
 
-        match storage_backend:
+        match self.storage_backend:
             case StorageBackend.GTC:
                 bucket_id = secrets_manager.get_secret("GT_CLOUD_BUCKET_ID", should_error_on_not_found=False)
 
@@ -56,20 +61,21 @@ class StaticFilesManager:
                     logger.warning(
                         "GT_CLOUD_BUCKET_ID secret is not available, falling back to local storage. Run `gtn init` to set it up."
                     )
-                    self.storage_driver = LocalStorageDriver()
+                    self.storage_driver = LocalStorageDriver(workspace_directory)
                 else:
                     static_files_directory = config_manager.get_config_value(
                         "static_files_directory", default="staticfiles"
                     )
                     self.storage_driver = GriptapeCloudStorageDriver(
+                        workspace_directory,
                         bucket_id=bucket_id,
                         api_key=secrets_manager.get_secret("GT_CLOUD_API_KEY"),
                         static_files_directory=static_files_directory,
                     )
             case StorageBackend.LOCAL:
-                self.storage_driver = LocalStorageDriver()
+                self.storage_driver = LocalStorageDriver(workspace_directory)
             case _:
-                msg = f"Invalid storage backend: {storage_backend}"
+                msg = f"Invalid storage backend: {self.storage_backend}"
                 raise ValueError(msg)
 
         if event_manager is not None:
@@ -82,6 +88,11 @@ class StaticFilesManager:
             event_manager.assign_manager_to_request_type(
                 CreateStaticFileDownloadUrlRequest, self.on_handle_create_static_file_download_url_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 static server
 
     def on_handle_create_static_file_request(
         self,
@@ -103,7 +114,7 @@ class StaticFilesManager:
             logger.error(msg)
             return CreateStaticFileResultFailure(error=msg, result_details=msg)
 
-        return CreateStaticFileResultSuccess(url=url)
+        return CreateStaticFileResultSuccess(url=url, result_details=f"Successfully created static file: {url}")
 
     def on_handle_create_static_file_upload_url_request(
         self,
@@ -118,15 +129,22 @@ class StaticFilesManager:
             A result object indicating success or failure.
         """
         file_name = request.file_name
+
+        resolved_directory = self._get_static_files_directory()
+        full_file_path = Path(resolved_directory) / file_name
+
         try:
-            response = self.storage_driver.create_signed_upload_url(file_name)
+            response = self.storage_driver.create_signed_upload_url(full_file_path)
         except ValueError as e:
             msg = f"Failed to create presigned URL for file {file_name}: {e}"
             logger.error(msg)
             return CreateStaticFileUploadUrlResultFailure(error=msg, result_details=msg)
 
         return CreateStaticFileUploadUrlResultSuccess(
-            url=response["url"], headers=response["headers"], method=response["method"]
+            url=response["url"],
+            headers=response["headers"],
+            method=response["method"],
+            result_details="Successfully created static file upload URL",
         )
 
     def on_handle_create_static_file_download_url_request(
@@ -142,14 +160,25 @@ class StaticFilesManager:
             A result object indicating success or failure.
         """
         file_name = request.file_name
+
+        resolved_directory = self._get_static_files_directory()
+        full_file_path = Path(resolved_directory) / file_name
+
         try:
-            url = self.storage_driver.create_signed_download_url(file_name)
+            url = self.storage_driver.create_signed_download_url(full_file_path)
         except ValueError as e:
             msg = f"Failed to create presigned URL for file {file_name}: {e}"
             logger.error(msg)
             return CreateStaticFileDownloadUrlResultFailure(error=msg, result_details=msg)
 
-        return CreateStaticFileDownloadUrlResultSuccess(url=url)
+        return CreateStaticFileDownloadUrlResultSuccess(
+            url=url, result_details="Successfully created static file download URL"
+        )
+
+    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
+        # Start static server in daemon thread if enabled
+        if self.storage_backend == StorageBackend.LOCAL:
+            threading.Thread(target=start_static_server, daemon=True, name="static-server").start()
 
     def save_static_file(self, data: bytes, file_name: str) -> str:
         """Saves a static file to the workspace directory.
@@ -163,7 +192,10 @@ class StaticFilesManager:
         Returns:
             The URL of the saved file.
         """
-        response = self.storage_driver.create_signed_upload_url(file_name)
+        resolved_directory = self._get_static_files_directory()
+        file_path = Path(resolved_directory) / file_name
+
+        response = self.storage_driver.create_signed_upload_url(file_path)
 
         try:
             response = httpx.request(
@@ -175,6 +207,47 @@ class StaticFilesManager:
             logger.error(msg)
             raise ValueError(msg) from e
 
-        url = self.storage_driver.create_signed_download_url(file_name)
+        url = self.storage_driver.create_signed_download_url(file_path)
 
         return url
+
+    def _get_static_files_directory(self) -> str:
+        """Get the appropriate static files directory based on the current workflow context.
+
+        Returns:
+            The directory path to use for static files, relative to the workspace directory.
+            If a workflow is active, returns the staticfiles subdirectory within the
+            workflow's directory relative to workspace. Otherwise, returns the staticfiles
+            subdirectory relative to workspace.
+        """
+        from griptape_nodes.node_library.workflow_registry import WorkflowRegistry
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        workspace_path = self.config_manager.workspace_path
+        static_files_subdir = self.config_manager.get_config_value("static_files_directory", default="staticfiles")
+
+        # Check if there's an active workflow context
+        context_manager = GriptapeNodes.ContextManager()
+        if context_manager.has_current_workflow():
+            try:
+                # Get the current workflow name and its file path
+                workflow_name = context_manager.get_current_workflow_name()
+                workflow = WorkflowRegistry.get_workflow_by_name(workflow_name)
+
+                # Get the directory containing the workflow file
+                workflow_file_path = Path(WorkflowRegistry.get_complete_file_path(workflow.file_path))
+                workflow_directory = workflow_file_path.parent
+
+                # Make the workflow directory relative to workspace
+                relative_workflow_dir = workflow_directory.relative_to(workspace_path)
+                return str(relative_workflow_dir / static_files_subdir)
+
+            except (KeyError, AttributeError) as e:
+                # If anything goes wrong getting workflow info, fall back to workspace-relative
+                logger.warning("Failed to get workflow directory for static files, using workspace: %s", e)
+            except ValueError as e:
+                # If workflow directory is not within workspace, fall back to workspace-relative
+                logger.warning("Workflow directory is outside workspace, using workspace-relative static files: %s", e)
+
+        # If no workflow context or workflow lookup failed, return just the static files subdirectory
+        return static_files_subdir

griptape_nodes/retained_mode/managers/sync_manager.py

@@ -13,7 +13,7 @@ from watchfiles import Change, PythonFilter, watch
 
 from griptape_nodes.drivers.storage.griptape_cloud_storage_driver import GriptapeCloudStorageDriver
 from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
-from griptape_nodes.retained_mode.events.base_events import AppEvent
+from griptape_nodes.retained_mode.events.base_events import AppEvent, ResultDetails
 from griptape_nodes.retained_mode.events.sync_events import (
     StartSyncAllCloudWorkflowsRequest,
     StartSyncAllCloudWorkflowsResultFailure,
@@ -130,8 +130,13 @@ class SyncManager:
             workflow_files = [file for file in files if file.endswith(".py")]
 
             if not workflow_files:
-                logger.info("No workflow files found in cloud storage")
-                return StartSyncAllCloudWorkflowsResultSuccess(sync_directory=str(sync_dir), total_workflows=0)
+                return StartSyncAllCloudWorkflowsResultSuccess(
+                    sync_directory=str(sync_dir),
+                    total_workflows=0,
+                    result_details=ResultDetails(
+                        message="No workflow files found in cloud storage.", level=logging.INFO
+                    ),
+                )
 
             # Start background sync with unique ID
             sync_task_id = str(uuid.uuid4())
@@ -149,9 +154,9 @@ class SyncManager:
             logger.error(details)
             return StartSyncAllCloudWorkflowsResultFailure(result_details=details)
         else:
-            logger.info("Started background sync for %d workflow files", len(workflow_files))
+            details = f"Started background sync for {len(workflow_files)} workflow files"
             return StartSyncAllCloudWorkflowsResultSuccess(
-                sync_directory=str(sync_dir), total_workflows=len(workflow_files)
+                sync_directory=str(sync_dir), total_workflows=len(workflow_files), result_details=details
             )
 
     def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
@@ -206,7 +211,10 @@ class SyncManager:
             msg = "Cloud storage api_key not configured. Set GT_CLOUD_API_KEY secret."
             raise RuntimeError(msg)
 
+        workspace_directory = Path(self._config_manager.get_config_value("workspace_directory"))
+
         return GriptapeCloudStorageDriver(
+            workspace_directory,
             bucket_id=bucket_id,
             base_url=base_url,
             api_key=api_key,
@@ -229,7 +237,7 @@ class SyncManager:
             sync_dir = self._sync_dir
 
             # Download file content from cloud
-            file_content = storage_driver.download_file(filename)
+            file_content = storage_driver.download_file(Path(filename))
 
             # Write to local sync directory
             local_file_path = sync_dir / filename
@@ -280,7 +288,7 @@ class SyncManager:
 
             # Upload to cloud storage using the upload_file method
             filename = file_path.name
-            storage_driver.upload_file(filename, file_content)
+            storage_driver.upload_file(Path(filename), file_content)
 
             logger.info("Successfully uploaded workflow file to cloud: %s", filename)
 
@@ -298,7 +306,7 @@ class SyncManager:
             filename = file_path.name
 
             # Use the storage driver's delete method
-            storage_driver.delete_file(filename)
+            storage_driver.delete_file(Path(filename))
             logger.info("Successfully deleted workflow file from cloud: %s", filename)
 
         except Exception as e:
@@ -385,7 +393,7 @@ class SyncManager:
         """
         try:
             # Download file content
-            file_content = storage_driver.download_file(file_name)
+            file_content = storage_driver.download_file(Path(file_name))
 
             # Extract just the filename (remove any directory prefixes)
             local_filename = Path(file_name).name