🐛 fix(manager.py): add support for registering factory dependencies to handle service dependencies

✨ feat(manager.py): add support for handling service dependencies when creating services
🔧 chore(manager.py): comment out validation for creating services before the settings service
🔧 chore(utils.py): add get_session_manager() function to retrieve the session manager service

src/backend/langflow/services/manager.py

@@ -1,5 +1,5 @@
 from langflow.services.schema import ServiceType
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
 if TYPE_CHECKING:
     from langflow.services.factory import ServiceFactory
@@ -13,13 +13,19 @@ class ServiceManager:
     def __init__(self):
         self.services = {}
         self.factories = {}
+        self.dependencies = {}
 
-    def register_factory(self, service_factory: "ServiceFactory"):
+    def register_factory(
+        self, service_factory: "ServiceFactory", dependencies: List[ServiceType] = None
+    ):
         """
-        Registers a new factory.
+        Registers a new factory with dependencies.
         """
-        if service_factory.service_class.name not in self.factories:
+        if dependencies is None:
-            self.factories[service_factory.service_class.name] = service_factory
+            dependencies = []
+        service_name = service_factory.service_class.name
+        self.factories[service_name] = service_factory
+        self.dependencies[service_name] = dependencies
 
     def get(self, service_name: ServiceType):
         """
@@ -32,17 +38,25 @@ class ServiceManager:
 
     def _create_service(self, service_name: ServiceType):
         """
-        Create a new service given its name.
+        Create a new service given its name, handling dependencies.
         """
         self._validate_service_creation(service_name)
 
-        if service_name == ServiceType.SETTINGS_MANAGER:
+        # Create dependencies first
-            self.services[service_name] = self.factories[service_name].create()
+        for dependency in self.dependencies.get(service_name, []):
-        else:
+            if dependency not in self.services:
-            settings_service = self.get(ServiceType.SETTINGS_MANAGER)
+                self._create_service(dependency)
-            self.services[service_name] = self.factories[service_name].create(
+
-                settings_service
+        # Collect the dependent services
-            )
+        dependent_services = {
+            dep.value: self.services[dep]
+            for dep in self.dependencies.get(service_name, [])
+        }
+
+        # Create the actual service
+        self.services[service_name] = self.factories[service_name].create(
+            **dependent_services
+        )
 
     def _validate_service_creation(self, service_name: ServiceType):
         """
@@ -53,13 +67,13 @@ class ServiceManager:
                 f"No factory registered for the service class '{service_name.name}'"
             )
 
-        if (
+        # if (
-            ServiceType.SETTINGS_MANAGER not in self.factories
+        #     ServiceType.SETTINGS_MANAGER not in self.factories
-            and service_name != ServiceType.SETTINGS_MANAGER
+        #     and service_name != ServiceType.SETTINGS_MANAGER
-        ):
+        # ):
-            raise ValueError(
+        #     raise ValueError(
-                f"Cannot create service '{service_name.name}' before the settings service"
+        #         f"Cannot create service '{service_name.name}' before the settings service"
-            )
+        #     )
 
     def update(self, service_name: ServiceType):
         """
@@ -81,11 +95,21 @@ def initialize_services():
     from langflow.services.cache import factory as cache_factory
     from langflow.services.chat import factory as chat_factory
     from langflow.services.settings import factory as settings_factory
+    from langflow.services.session import factory as session_manager_factory
 
     service_manager.register_factory(settings_factory.SettingsManagerFactory())
-    service_manager.register_factory(database_factory.DatabaseManagerFactory())
+    service_manager.register_factory(
-    service_manager.register_factory(cache_factory.CacheManagerFactory())
+        database_factory.DatabaseManagerFactory(),
+        dependencies=[ServiceType.SETTINGS_MANAGER],
+    )
+    service_manager.register_factory(
+        cache_factory.CacheManagerFactory(), dependencies=[ServiceType.SETTINGS_MANAGER]
+    )
     service_manager.register_factory(chat_factory.ChatManagerFactory())
+    service_manager.register_factory(
+        session_manager_factory.SessionManagerFactory(),
+        dependencies=[ServiceType.CACHE_MANAGER],
+    )
 
     # Test cache connection
     service_manager.get(ServiceType.CACHE_MANAGER)

src/backend/langflow/services/schema.py

@@ -11,3 +11,4 @@ class ServiceType(str, Enum):
     SETTINGS_MANAGER = "settings_manager"
     DATABASE_MANAGER = "database_manager"
     CHAT_MANAGER = "chat_manager"
+    SESSION_MANAGER = "session_manager"

src/backend/langflow/services/utils.py

@@ -20,3 +20,7 @@ def get_session():
 
 def get_cache_manager():
     return service_manager.get(ServiceType.CACHE_MANAGER)
+
+
+def get_session_manager():
+    return service_manager.get(ServiceType.SESSION_MANAGER)