griptape-nodes 0.53.0__py3-none-any.whl → 0.54.1__py3-none-any.whl

griptape_nodes/retained_mode/managers/workflow_manager.py

@@ -317,17 +317,22 @@ class WorkflowManager:
 
     def on_libraries_initialization_complete(self) -> None:
         # All of the libraries have loaded, and any workflows they came with have been registered.
-        # See if there are USER workflow JSONs to load.
+        # Discover workflows from both config and workspace.
         default_workflow_section = "app_events.on_app_initialization_complete.workflows_to_register"
+        config_mgr = GriptapeNodes.ConfigManager()
 
-        # Use the request/response pattern for workflow registration
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+        workflows_to_register = []
+
+        # Add from config
+        config_workflows = config_mgr.get_config_value(default_workflow_section, default=[])
+        workflows_to_register.extend(config_workflows)
 
-        register_request = RegisterWorkflowsFromConfigRequest(config_section=default_workflow_section)
-        register_result = GriptapeNodes.handle_request(register_request)
+        # Add from workspace (avoiding duplicates)
+        workspace_path = config_mgr.workspace_path
+        workflows_to_register.extend([workspace_path])
 
-        if not isinstance(register_result, RegisterWorkflowsFromConfigResultSuccess):
-            logger.warning("Failed to register workflows from configuration during library initialization")
+        # Register all discovered workflows at once if any were found
+        self._process_workflows_for_registration(workflows_to_register)
 
         # Print it all out nicely.
         self.print_workflow_load_status()
@@ -340,7 +345,6 @@ class WorkflowManager:
                 paths_to_remove.add(workflow_path.lower())
 
         if paths_to_remove:
-            config_mgr = GriptapeNodes.ConfigManager()
             workflows_to_register = config_mgr.get_config_value(default_workflow_section)
             if workflows_to_register:
                 workflows_to_register = [
@@ -602,8 +606,8 @@ class WorkflowManager:
             if not execution_result.execution_successful:
                 result_messages = []
                 if context_warning:
-                    result_messages.append(ResultDetail(message=context_warning, level="WARNING"))
-                result_messages.append(ResultDetail(message=execution_result.execution_details, level="ERROR"))
+                    result_messages.append(ResultDetail(message=context_warning, level=logging.WARNING))
+                result_messages.append(ResultDetail(message=execution_result.execution_details, level=logging.ERROR))
 
                 # Attempt to clear everything out, as we modified the engine state getting here.
                 clear_all_request = ClearAllObjectStateRequest(i_know_what_im_doing=True)
@@ -615,8 +619,8 @@ class WorkflowManager:
         # Success!
         result_messages = []
         if context_warning:
-            result_messages.append(ResultDetail(message=context_warning, level="WARNING"))
-        result_messages.append(ResultDetail(message=execution_result.execution_details, level="DEBUG"))
+            result_messages.append(ResultDetail(message=context_warning, level=logging.WARNING))
+        result_messages.append(ResultDetail(message=execution_result.execution_details, level=logging.DEBUG))
         return RunWorkflowFromRegistryResultSuccess(result_details=ResultDetails(*result_messages))
 
     def on_register_workflow_request(self, request: RegisterWorkflowRequest) -> ResultPayload:
@@ -631,7 +635,8 @@ class WorkflowManager:
         return RegisterWorkflowResultSuccess(
             workflow_name=workflow.metadata.name,
             result_details=ResultDetails(
-                message=f"Successfully registered workflow: {workflow.metadata.name}", level="INFO"
+                message=f"Successfully registered workflow: {workflow.metadata.name}",
+                level=logging.DEBUG,
             ),
         )
 
@@ -671,7 +676,7 @@ class WorkflowManager:
         return ImportWorkflowResultSuccess(
             workflow_name=register_result.workflow_name,
             result_details=ResultDetails(
-                message=f"Successfully imported workflow: {register_result.workflow_name}", level="INFO"
+                message=f"Successfully imported workflow: {register_result.workflow_name}", level=logging.INFO
             ),
         )
 
@@ -705,7 +710,7 @@ class WorkflowManager:
             details = f"Failed to delete workflow file with path '{workflow.file_path}'. Exception: {e}"
             return DeleteWorkflowResultFailure(result_details=details)
         return DeleteWorkflowResultSuccess(
-            result_details=ResultDetails(message=f"Successfully deleted workflow: {request.name}", level="INFO")
+            result_details=ResultDetails(message=f"Successfully deleted workflow: {request.name}", level=logging.INFO)
         )
 
     def on_rename_workflow_request(self, request: RenameWorkflowRequest) -> ResultPayload:
@@ -722,7 +727,7 @@ class WorkflowManager:
 
         return RenameWorkflowResultSuccess(
             result_details=ResultDetails(
-                message=f"Successfully renamed workflow to: {request.requested_name}", level="INFO"
+                message=f"Successfully renamed workflow to: {request.requested_name}", level=logging.INFO
             )
         )
 
@@ -784,17 +789,17 @@ class WorkflowManager:
         except OSError as e:
             error_messages = []
             main_error = f"Failed to move workflow file '{current_file_path}' to '{new_absolute_path}': {e!s}"
-            error_messages.append(ResultDetail(message=main_error, level="ERROR"))
+            error_messages.append(ResultDetail(message=main_error, level=logging.ERROR))
 
             # Attempt to rollback if file was moved but registry update failed
             if new_absolute_path.exists() and not Path(current_file_path).exists():
                 try:
                     new_absolute_path.rename(current_file_path)
                     rollback_message = f"Rolled back file move for workflow '{request.workflow_name}'"
-                    error_messages.append(ResultDetail(message=rollback_message, level="INFO"))
+                    error_messages.append(ResultDetail(message=rollback_message, level=logging.INFO))
                 except OSError:
                     rollback_failure = f"Failed to rollback file move for workflow '{request.workflow_name}'"
-                    error_messages.append(ResultDetail(message=rollback_failure, level="ERROR"))
+                    error_messages.append(ResultDetail(message=rollback_failure, level=logging.ERROR))
 
             return MoveWorkflowResultFailure(result_details=ResultDetails(*error_messages))
         except Exception as e:
@@ -803,7 +808,7 @@ class WorkflowManager:
         else:
             details = f"Successfully moved workflow '{request.workflow_name}' to '{new_relative_path}'"
             return MoveWorkflowResultSuccess(
-                moved_file_path=new_relative_path, result_details=ResultDetails(message=details, level="INFO")
+                moved_file_path=new_relative_path, result_details=ResultDetails(message=details, level=logging.INFO)
             )
 
     def on_load_workflow_metadata_request(  # noqa: C901, PLR0912, PLR0915
@@ -1055,21 +1060,7 @@ class WorkflowManager:
             self.register_list_of_workflows(workflows_to_register)
 
     def register_list_of_workflows(self, workflows_to_register: list[str]) -> None:
-        for workflow_to_register in workflows_to_register:
-            path = Path(workflow_to_register)
-
-            if path.is_dir():
-                # If it's a directory, register all the workflows in it.
-                for workflow_file in path.glob("*.py"):
-                    # Check that the python file has script metadata
-                    metadata_blocks = self.get_workflow_metadata(
-                        workflow_file, block_name=WorkflowManager.WORKFLOW_METADATA_HEADER
-                    )
-                    if len(metadata_blocks) == 1:
-                        self._register_workflow(str(workflow_file))
-            else:
-                # If it's a file, register it directly.
-                self._register_workflow(str(path))
+        self._process_workflows_for_registration(workflows_to_register)
 
     def _register_workflow(self, workflow_to_register: str) -> bool:
         """Registers a workflow from a file.
@@ -1467,7 +1458,7 @@ class WorkflowManager:
         existing_workflow.metadata = workflow_metadata
         details = f"Successfully saved workflow to: {file_path}"
         return SaveWorkflowResultSuccess(
-            file_path=str(file_path), result_details=ResultDetails(message=details, level="INFO")
+            file_path=str(file_path), result_details=ResultDetails(message=details, level=logging.INFO)
         )
 
     def _generate_workflow_metadata(  # noqa: PLR0913
@@ -1615,7 +1606,7 @@ class WorkflowManager:
             ),
         )
 
-        # Create conditional logic: workflow_executor = workflow_executor or LocalWorkflowExecutor()
+        # Create conditional logic: workflow_executor = workflow_executor or LocalWorkflowExecutor(storage_backend=storage_backend_enum)
         executor_assign = ast.Assign(
             targets=[ast.Name(id="workflow_executor", ctx=ast.Store())],
             value=ast.BoolOp(
@@ -1625,31 +1616,45 @@ class WorkflowManager:
                     ast.Call(
                         func=ast.Name(id="LocalWorkflowExecutor", ctx=ast.Load()),
                         args=[],
-                        keywords=[],
+                        keywords=[
+                            ast.keyword(
+                                arg="storage_backend", value=ast.Name(id="storage_backend_enum", ctx=ast.Load())
+                            ),
+                        ],
                     ),
                 ],
             ),
         )
-        run_call = ast.Expr(
-            value=ast.Await(
-                value=ast.Call(
-                    func=ast.Attribute(
-                        value=ast.Name(id="workflow_executor", ctx=ast.Load()),
-                        attr="arun",
-                        ctx=ast.Load(),
-                    ),
-                    args=[],
-                    keywords=[
-                        ast.keyword(arg="workflow_name", value=ast.Constant(flow_name)),
-                        ast.keyword(arg="flow_input", value=ast.Name(id="input", ctx=ast.Load())),
-                        ast.keyword(arg="storage_backend", value=ast.Name(id="storage_backend_enum", ctx=ast.Load())),
-                    ],
+        # Use async context manager for workflow execution
+        with_stmt = ast.AsyncWith(
+            items=[
+                ast.withitem(
+                    context_expr=ast.Name(id="workflow_executor", ctx=ast.Load()),
+                    optional_vars=ast.Name(id="executor", ctx=ast.Store()),
                 )
-            )
+            ],
+            body=[
+                ast.Expr(
+                    value=ast.Await(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="executor", ctx=ast.Load()),
+                                attr="arun",
+                                ctx=ast.Load(),
+                            ),
+                            args=[],
+                            keywords=[
+                                ast.keyword(arg="workflow_name", value=ast.Constant(flow_name)),
+                                ast.keyword(arg="flow_input", value=ast.Name(id="input", ctx=ast.Load())),
+                            ],
+                        )
+                    )
+                )
+            ],
         )
         return_stmt = ast.Return(
             value=ast.Attribute(
-                value=ast.Name(id="workflow_executor", ctx=ast.Load()),
+                value=ast.Name(id="executor", ctx=ast.Load()),
                 attr="output",
                 ctx=ast.Load(),
             )
@@ -1659,7 +1664,7 @@ class WorkflowManager:
         async_func_def = ast.AsyncFunctionDef(
             name="aexecute_workflow",
             args=args,
-            body=[ensure_context_call, storage_backend_convert, executor_assign, run_call, return_stmt],
+            body=[ensure_context_call, storage_backend_convert, executor_assign, with_stmt, return_stmt],
             decorator_list=[],
             returns=return_annotation,
             type_params=[],
@@ -3196,15 +3201,15 @@ class WorkflowManager:
                 result_messages = []
                 if isinstance(register_workflow_result, RegisterWorkflowResultSuccess):
                     success_message = f"Successfully registered new workflow with file '{workflow_file.name}'."
-                    result_messages.append(ResultDetail(message=success_message, level="INFO"))
+                    result_messages.append(ResultDetail(message=success_message, level=logging.INFO))
                 else:
                     failure_message = f"Failed to register workflow with file '{workflow_file.name}': {cast('RegisterWorkflowResultFailure', register_workflow_result).exception}"
-                    result_messages.append(ResultDetail(message=failure_message, level="WARNING"))
+                    result_messages.append(ResultDetail(message=failure_message, level=logging.WARNING))
             else:
                 metadata_failure_message = (
                     f"Failed to load metadata for workflow file '{workflow_file.name}'. Not registering workflow."
                 )
-                result_messages = [ResultDetail(message=metadata_failure_message, level="WARNING")]
+                result_messages = [ResultDetail(message=metadata_failure_message, level=logging.WARNING)]
 
             # Log all messages through consolidated ResultDetails
             ResultDetails(*result_messages)
@@ -3402,7 +3407,7 @@ class WorkflowManager:
             return BranchWorkflowResultSuccess(
                 branched_workflow_name=branch_name,
                 original_workflow_name=request.workflow_name,
-                result_details=ResultDetails(message=details, level="INFO"),
+                result_details=ResultDetails(message=details, level=logging.INFO),
             )
 
         except Exception as e:
@@ -3476,16 +3481,16 @@ class WorkflowManager:
                 WorkflowRegistry.delete_workflow_by_name(request.workflow_name)
                 Path(branch_content_file_path).unlink()
                 cleanup_message = f"Deleted branch workflow file and registry entry for '{request.workflow_name}'"
-                result_messages.append(ResultDetail(message=cleanup_message, level="INFO"))
+                result_messages.append(ResultDetail(message=cleanup_message, level=logging.INFO))
             except Exception as delete_error:
                 warning_message = (
                     f"Failed to fully clean up branch workflow '{request.workflow_name}': {delete_error!s}"
                 )
-                result_messages.append(ResultDetail(message=warning_message, level="WARNING"))
+                result_messages.append(ResultDetail(message=warning_message, level=logging.WARNING))
                 # Continue anyway - the merge was successful even if cleanup failed
 
             success_message = f"Successfully merged branch workflow '{request.workflow_name}' into source workflow '{source_workflow_name}'"
-            result_messages.append(ResultDetail(message=success_message, level="INFO"))
+            result_messages.append(ResultDetail(message=success_message, level=logging.INFO))
 
             return MergeWorkflowBranchResultSuccess(
                 merged_workflow_name=source_workflow_name, result_details=ResultDetails(*result_messages)
@@ -3559,7 +3564,8 @@ class WorkflowManager:
         else:
             details = f"Successfully reset branch workflow '{request.workflow_name}' to match source workflow '{source_workflow_name}'"
             return ResetWorkflowBranchResultSuccess(
-                reset_workflow_name=request.workflow_name, result_details=ResultDetails(message=details, level="INFO")
+                reset_workflow_name=request.workflow_name,
+                result_details=ResultDetails(message=details, level=logging.INFO),
             )
 
     def on_compare_workflows_request(self, request: CompareWorkflowsRequest) -> ResultPayload:
@@ -3807,7 +3813,7 @@ class WorkflowManager:
                 failed_workflows=failed,
                 result_details=ResultDetails(
                     message=f"Successfully processed workflows: {len(succeeded)} succeeded, {len(failed)} failed.",
-                    level="INFO",
+                    level=logging.INFO,
                 ),
             )
 
@@ -3820,33 +3826,9 @@ class WorkflowManager:
         succeeded = []
         failed = []
 
-        for workflow_to_register in workflows_to_register:
-            path = Path(workflow_to_register)
-
-            if path.is_dir():
-                dir_result = self._process_workflow_directory(path)
-                succeeded.extend(dir_result.succeeded)
-                failed.extend(dir_result.failed)
-            elif path.suffix == ".py":
-                workflow_name = self._process_single_workflow_file(path)
-                if workflow_name:
-                    succeeded.append(workflow_name)
-                else:
-                    failed.append(str(path))
-
-        return WorkflowRegistrationResult(succeeded=succeeded, failed=failed)
-
-    def _process_workflow_directory(self, directory_path: Path) -> WorkflowRegistrationResult:
-        """Process all workflow files in a directory.
-
-        Returns:
-            WorkflowRegistrationResult with succeeded and failed workflow names
-        """
-        succeeded = []
-        failed = []
-
-        for workflow_file in directory_path.glob("*.py"):
-            # Check that the python file has script metadata
+        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
             )
@@ -3857,6 +3839,21 @@ class WorkflowManager:
                 else:
                     failed.append(str(workflow_file))
 
+        def process_path(path: Path) -> None:
+            """Process a path, handling both files and directories."""
+            if not path.exists():
+                failed.append(str(path))
+                return
+            if path.is_dir():
+                # Process all Python files recursively in the directory
+                for workflow_file in path.rglob("*.py"):
+                    process_workflow_file(workflow_file)
+            elif path.suffix == ".py":
+                process_workflow_file(path)
+
+        for workflow_to_register in workflows_to_register:
+            process_path(Path(workflow_to_register))
+
         return WorkflowRegistrationResult(succeeded=succeeded, failed=failed)
 
     def _process_single_workflow_file(self, workflow_file: Path) -> str | None:
@@ -3865,6 +3862,8 @@ class WorkflowManager:
         Returns:
             Workflow name if registered successfully, None if failed or skipped
         """
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
         # Parse metadata once and use it for both registration check and actual registration
         load_metadata_request = LoadWorkflowMetadata(file_name=str(workflow_file))
         load_metadata_result = self.on_load_workflow_metadata_request(load_metadata_request)
@@ -3880,10 +3879,20 @@ class WorkflowManager:
             logger.debug("Skipping already registered workflow: %s", workflow_file)
             return None
 
+        # Convert to relative path if the workflow is under workspace_path
+        config_mgr = GriptapeNodes.ConfigManager()
+        workspace_path = config_mgr.workspace_path
+
+        if workflow_file.is_relative_to(workspace_path):
+            relative_path = workflow_file.relative_to(workspace_path)
+            file_path_to_register = str(relative_path)
+        else:
+            file_path_to_register = str(workflow_file)
+
         # Register workflow using existing method with parsed metadata available
         # The _register_workflow method will re-parse metadata, but this is acceptable
         # since we've already validated it's parseable and the duplicate work is minimal
-        if self._register_workflow(str(workflow_file)):
+        if self._register_workflow(file_path_to_register):
             return workflow_metadata.name
         return None
 

griptape_nodes/retained_mode/retained_mode.py

@@ -10,6 +10,7 @@ from griptape_nodes.retained_mode.events.base_events import (
 )
 from griptape_nodes.retained_mode.events.config_events import (
     GetConfigCategoryRequest,
+    GetConfigSchemaRequest,
     GetConfigValueRequest,
     SetConfigCategoryRequest,
     SetConfigValueRequest,
@@ -1396,6 +1397,24 @@ class RetainedMode:
         result = GriptapeNodes().handle_request(request)
         return result
 
+    @classmethod
+    def get_config_schema(cls) -> ResultPayload:
+        """Gets the JSON schema for the configuration model.
+
+        Returns:
+            ResultPayload: Contains the configuration schema with field types, enums, and validation rules.
+
+        Example:
+            # Get the configuration schema
+            schema_result = cmd.get_config_schema()
+            if isinstance(schema_result, GetConfigSchemaResultSuccess):
+                schema = schema_result.schema
+                # Use schema to render appropriate UI components
+        """
+        request = GetConfigSchemaRequest()
+        result = GriptapeNodes().handle_request(request)
+        return result
+
     @classmethod
     def rename(cls, object_name: str, requested_name: str) -> ResultPayload:
         """Renames a node or flow.

griptape_nodes/servers/__init__.py

@@ -0,0 +1 @@
+"""Package for web servers the engine may need to start."""

griptape_nodes/{mcp_server/server.py → servers/mcp.py}

@@ -16,7 +16,6 @@ from pydantic import TypeAdapter
 from rich.logging import RichHandler
 from starlette.types import Receive, Scope, Send
 
-from griptape_nodes.mcp_server.ws_request_manager import AsyncRequestManager, WebSocketConnectionManager
 from griptape_nodes.retained_mode.events.base_events import RequestPayload
 from griptape_nodes.retained_mode.events.connection_events import (
     CreateConnectionRequest,
@@ -38,6 +37,7 @@ from griptape_nodes.retained_mode.events.parameter_events import (
 )
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
 from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
+from griptape_nodes.servers.ws_request_manager import AsyncRequestManager, WebSocketConnectionManager
 
 SUPPORTED_REQUEST_EVENTS: dict[str, type[RequestPayload]] = {
     # Nodes

griptape_nodes/{app/api.py → servers/static.py}

@@ -4,15 +4,16 @@ import binascii
 import logging
 import os
 from pathlib import Path
-from typing import Annotated
 from urllib.parse import urljoin
 
 import uvicorn
-from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from rich.logging import RichHandler
 
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
 # Whether to enable the static server
 STATIC_SERVER_ENABLED = os.getenv("STATIC_SERVER_ENABLED", "true").lower() == "true"
 # Host of the static server
@@ -20,7 +21,7 @@ STATIC_SERVER_HOST = os.getenv("STATIC_SERVER_HOST", "localhost")
 # Port of the static server
 STATIC_SERVER_PORT = int(os.getenv("STATIC_SERVER_PORT", "8124"))
 # URL path for the static server
-STATIC_SERVER_URL = os.getenv("STATIC_SERVER_URL", "/static")
+STATIC_SERVER_URL = os.getenv("STATIC_SERVER_URL", "/workspace")
 # Log level for the static server
 STATIC_SERVER_LOG_LEVEL = os.getenv("STATIC_SERVER_LOG_LEVEL", "ERROR").lower()
 
@@ -28,18 +29,6 @@ logger = logging.getLogger("griptape_nodes_api")
 logging.getLogger("uvicorn").addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
 
 
-# Global static directory - initialized as None and set when starting the API
-static_dir: Path | None = None
-
-
-def get_static_dir() -> Path:
-    """FastAPI dependency to get the static directory."""
-    if static_dir is None:
-        msg = "Static directory is not initialized"
-        raise HTTPException(status_code=500, detail=msg)
-    return static_dir
-
-
 """Create and configure the FastAPI application."""
 app = FastAPI()
 
@@ -52,35 +41,34 @@ async def _create_static_file_upload_url(request: Request) -> dict:
     """
     base_url = request.base_url
     body = await request.json()
-    file_name = body["file_name"]
-    url = urljoin(str(base_url), f"/static-uploads/{file_name}")
+    file_path = body["file_path"].lstrip("/")
+    url = urljoin(str(base_url), f"/static-uploads/{file_path}")
 
     return {"url": url}
 
 
 @app.put("/static-uploads/{file_path:path}")
-async def _create_static_file(
-    request: Request, file_path: str, static_directory: Annotated[Path, Depends(get_static_dir)]
-) -> dict:
+async def _create_static_file(request: Request, file_path: str) -> dict:
     """Upload a static file to the static server."""
     if not STATIC_SERVER_ENABLED:
         msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
         raise ValueError(msg)
 
-    file_full_path = Path(static_directory / file_path)
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+    full_file_path = workspace_directory / file_path
 
     # Create parent directories if they don't exist
-    file_full_path.parent.mkdir(parents=True, exist_ok=True)
+    full_file_path.parent.mkdir(parents=True, exist_ok=True)
 
     data = await request.body()
     try:
-        file_full_path.write_bytes(data)
+        full_file_path.write_bytes(data)
     except binascii.Error as e:
         msg = f"Invalid base64 encoding for file {file_path}."
         logger.error(msg)
         raise HTTPException(status_code=400, detail=msg) from e
     except (OSError, PermissionError) as e:
-        msg = f"Failed to write file {file_path} to {static_dir}: {e}"
+        msg = f"Failed to write file {full_file_path}: {e}"
         logger.error(msg)
         raise HTTPException(status_code=500, detail=msg) from e
 
@@ -88,19 +76,28 @@ async def _create_static_file(
     return {"url": static_url}
 
 
+@app.get("/static-uploads/{file_path_prefix:path}")
 @app.get("/static-uploads/")
-async def _list_static_files(static_directory: Annotated[Path, Depends(get_static_dir)]) -> dict:
-    """List all static files in the static server."""
+async def _list_static_files(file_path_prefix: str = "") -> dict:
+    """List static files in the static server under the specified path prefix."""
     if not STATIC_SERVER_ENABLED:
         msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
         raise HTTPException(status_code=500, detail=msg)
 
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+
+    # Handle the prefix path
+    if file_path_prefix:
+        target_directory = workspace_directory / file_path_prefix
+    else:
+        target_directory = workspace_directory
+
     try:
         file_names = []
-        if static_directory.exists():
-            for file_path in static_directory.rglob("*"):
+        if target_directory.exists() and target_directory.is_dir():
+            for file_path in target_directory.rglob("*"):
                 if file_path.is_file():
-                    relative_path = file_path.relative_to(static_directory)
+                    relative_path = file_path.relative_to(workspace_directory)
                     file_names.append(str(relative_path))
     except (OSError, PermissionError) as e:
         msg = f"Failed to list files in static directory: {e}"
@@ -111,13 +108,14 @@ async def _list_static_files(static_directory: Annotated[Path, Depends(get_stati
 
 
 @app.delete("/static-files/{file_path:path}")
-async def _delete_static_file(file_path: str, static_directory: Annotated[Path, Depends(get_static_dir)]) -> dict:
+async def _delete_static_file(file_path: str) -> dict:
     """Delete a static file from the static server."""
     if not STATIC_SERVER_ENABLED:
         msg = "Static server is not enabled. Please set STATIC_SERVER_ENABLED to True."
         raise HTTPException(status_code=500, detail=msg)
 
-    file_full_path = Path(static_directory / file_path)
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+    file_full_path = workspace_directory / file_path
 
     # Check if file exists
     if not file_full_path.exists():
@@ -141,13 +139,10 @@ async def _delete_static_file(file_path: str, static_directory: Annotated[Path,
         return {"message": f"File {file_path} deleted successfully"}
 
 
-def _setup_app(static_directory: Path) -> None:
+def _setup_app() -> None:
     """Setup FastAPI app with middleware and static files."""
-    global static_dir  # noqa: PLW0603
-    static_dir = static_directory
-
-    if not static_dir.exists():
-        static_dir.mkdir(parents=True, exist_ok=True)
+    workspace_directory = Path(GriptapeNodes.ConfigManager().get_config_value("workspace_directory"))
+    static_files_directory = Path(GriptapeNodes.ConfigManager().get_config_value("static_files_directory"))
 
     app.add_middleware(
         CORSMiddleware,
@@ -163,15 +158,23 @@ def _setup_app(static_directory: Path) -> None:
 
     app.mount(
         STATIC_SERVER_URL,
-        StaticFiles(directory=static_directory),
+        StaticFiles(directory=workspace_directory),
+        name="workspace",
+    )
+    static_files_path = workspace_directory / static_files_directory
+    static_files_path.mkdir(parents=True, exist_ok=True)
+    # For legacy urls
+    app.mount(
+        "/static",
+        StaticFiles(directory=workspace_directory / static_files_directory),
         name="static",
     )
 
 
-def start_static_server(static_directory: Path) -> None:
+def start_static_server() -> None:
     """Run uvicorn server synchronously using uvicorn.run."""
     # Setup the FastAPI app
-    _setup_app(static_directory)
+    _setup_app()
 
     try:
         # Run server using uvicorn.run