nvidia-nat 1.4.0a20251112__py3-none-any.whl → 1.4.0a20260113__py3-none-any.whl

nat/builder/workflow_builder.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -28,7 +28,8 @@ from typing import cast
 from nat.authentication.interfaces import AuthProviderBase
 from nat.builder.builder import Builder
 from nat.builder.builder import UserManagerHolder
-from nat.builder.component_utils import ComponentInstanceData
+from nat.builder.child_builder import ChildBuilder
+from nat.builder.component_utils import WORKFLOW_COMPONENT_NAME
 from nat.builder.component_utils import build_dependency_sequence
 from nat.builder.context import Context
 from nat.builder.context import ContextState
@@ -40,6 +41,7 @@ from nat.builder.function import LambdaFunction
 from nat.builder.function_info import FunctionInfo
 from nat.builder.llm import LLMProviderInfo
 from nat.builder.retriever import RetrieverProviderInfo
+from nat.builder.sync_builder import SyncBuilder
 from nat.builder.workflow import Workflow
 from nat.cli.type_registry import GlobalTypeRegistry
 from nat.cli.type_registry import TypeRegistry
@@ -51,17 +53,25 @@ from nat.data_models.component_ref import FunctionGroupRef
 from nat.data_models.component_ref import FunctionRef
 from nat.data_models.component_ref import LLMRef
 from nat.data_models.component_ref import MemoryRef
+from nat.data_models.component_ref import MiddlewareRef
 from nat.data_models.component_ref import ObjectStoreRef
 from nat.data_models.component_ref import RetrieverRef
+from nat.data_models.component_ref import TrainerAdapterRef
+from nat.data_models.component_ref import TrainerRef
+from nat.data_models.component_ref import TrajectoryBuilderRef
 from nat.data_models.component_ref import TTCStrategyRef
 from nat.data_models.config import Config
 from nat.data_models.config import GeneralConfig
 from nat.data_models.embedder import EmbedderBaseConfig
+from nat.data_models.finetuning import TrainerAdapterConfig
+from nat.data_models.finetuning import TrainerConfig
+from nat.data_models.finetuning import TrajectoryBuilderConfig
 from nat.data_models.function import FunctionBaseConfig
 from nat.data_models.function import FunctionGroupBaseConfig
 from nat.data_models.function_dependencies import FunctionDependencies
 from nat.data_models.llm import LLMBaseConfig
 from nat.data_models.memory import MemoryBaseConfig
+from nat.data_models.middleware import MiddlewareBaseConfig
 from nat.data_models.object_store import ObjectStoreBaseConfig
 from nat.data_models.retriever import RetrieverBaseConfig
 from nat.data_models.telemetry_exporter import TelemetryExporterBaseConfig
@@ -70,12 +80,16 @@ from nat.experimental.decorators.experimental_warning_decorator import experimen
 from nat.experimental.test_time_compute.models.stage_enums import PipelineTypeEnum
 from nat.experimental.test_time_compute.models.stage_enums import StageTypeEnum
 from nat.experimental.test_time_compute.models.strategy_base import StrategyBase
+from nat.finetuning.interfaces.finetuning_runner import Trainer
+from nat.finetuning.interfaces.trainer_adapter import TrainerAdapter
+from nat.finetuning.interfaces.trajectory_builder import TrajectoryBuilder
 from nat.memory.interfaces import MemoryEditor
+from nat.middleware.function_middleware import FunctionMiddleware
+from nat.middleware.middleware import Middleware
 from nat.object_store.interfaces import ObjectStore
 from nat.observability.exporter.base_exporter import BaseExporter
 from nat.profiler.decorators.framework_wrapper import chain_wrapped_build_fn
 from nat.profiler.utils import detect_llm_frameworks_in_build_fn
-from nat.retriever.interface import Retriever
 from nat.utils.type_utils import override
 
 logger = logging.getLogger(__name__)
@@ -141,6 +155,157 @@ class ConfiguredTTCStrategy:
     instance: StrategyBase
 
 
+@dataclasses.dataclass
+class ConfiguredMiddleware:
+    config: MiddlewareBaseConfig
+    instance: Middleware
+
+
+@dataclasses.dataclass
+class ConfiguredTrainer:
+    config: TrainerConfig
+    instance: Trainer
+
+
+@dataclasses.dataclass
+class ConfiguredTrainerAdapter:
+    config: TrainerAdapterConfig
+    instance: TrainerAdapter
+
+
+@dataclasses.dataclass
+class ConfiguredTrajectoryBuilder:
+    config: TrajectoryBuilderConfig
+    instance: TrajectoryBuilder
+
+
+def _log_build_failure(component_name: str,
+                       component_type: str,
+                       completed_components: list[tuple[str, str]],
+                       remaining_components: list[tuple[str, str]],
+                       original_error: Exception) -> None:
+    """
+        Common method to log comprehensive build failure information.
+
+        Args:
+            component_name (str): The name of the component that failed to build
+            component_type (str): The type of the component that failed to build
+            completed_components (list[tuple[str, str]]): List of (name, type) tuples for successfully built components
+            remaining_components (list[tuple[str, str]]): List of (name, type) tuples for components still to be built
+            original_error (Exception): The original exception that caused the failure
+        """
+    logger.error("Failed to initialize component %s (%s)", component_name, component_type)
+
+    if completed_components:
+        logger.error("Successfully built components:")
+        for name, comp_type in completed_components:
+            logger.error("- %s (%s)", name, comp_type)
+    else:
+        logger.error("No components were successfully built before this failure")
+
+    if remaining_components:
+        logger.error("Remaining components to build:")
+        for name, comp_type in remaining_components:
+            logger.error("- %s (%s)", name, comp_type)
+    else:
+        logger.error("No remaining components to build")
+
+    logger.error("Original error: %s", original_error, exc_info=True)
+
+
+async def _build_function_impl(
+    *,
+    name: str,
+    config: FunctionBaseConfig,
+    registry: TypeRegistry,
+    exit_stack: AsyncExitStack,
+    inner_builder: 'ChildBuilder',
+    llms: dict[str, LLMProviderInfo],
+    dependencies: dict[str, FunctionDependencies],
+    middleware_instances: list[FunctionMiddleware],
+) -> ConfiguredFunction:
+    """
+    Helper for core function building logic.
+
+    Args:
+        name: The function name
+        config: The function configuration
+        registry: Type registry to look up the function registration
+        exit_stack: Async exit stack for context management
+        inner_builder: ChildBuilder instance for dependency tracking
+        llms: Dictionary of LLM instances
+        dependencies: Dictionary to store function dependencies
+        middleware_instances: Pre-resolved middleware instances
+    """
+    registration = registry.get_function(type(config))
+
+    function_frameworks = detect_llm_frameworks_in_build_fn(registration)
+    build_fn = chain_wrapped_build_fn(registration.build_fn, llms, function_frameworks)
+
+    build_result = await exit_stack.enter_async_context(build_fn(config, inner_builder))
+
+    dependencies[name] = inner_builder.dependencies
+
+    # If the build result is a function, wrap it in a FunctionInfo
+    if inspect.isfunction(build_result):
+        build_result = FunctionInfo.from_fn(build_result)
+
+    if isinstance(build_result, FunctionInfo):
+        build_result = LambdaFunction.from_info(config=config, info=build_result, instance_name=name)
+
+    if not isinstance(build_result, Function):
+        raise ValueError("Expected a function, FunctionInfo object, or FunctionBase object to be "
+                         f"returned from the function builder. Got {type(build_result)}")
+
+    build_result.configure_middleware(middleware_instances)
+
+    return ConfiguredFunction(config=config, instance=build_result)
+
+
+async def _build_function_group_impl(
+    *,
+    name: str,
+    config: FunctionGroupBaseConfig,
+    registry: TypeRegistry,
+    exit_stack: AsyncExitStack,
+    inner_builder: 'ChildBuilder',
+    llms: dict[str, LLMProviderInfo],
+    dependencies: dict[str, FunctionDependencies],
+    middleware_instances: list[FunctionMiddleware],
+) -> ConfiguredFunctionGroup:
+    """
+    Core function group building logic shared between WorkflowBuilder and PerUserWorkflowBuilder.
+
+    Args:
+        name: The function group name
+        config: The function group configuration
+        registry: Type registry to look up the function group registration
+        exit_stack: Async exit stack for context management
+        inner_builder: ChildBuilder instance for dependency tracking
+        llms: Dictionary of LLM instances
+        dependencies: Dictionary to store function group dependencies
+        middleware_instances: Pre-resolved middleware instances
+    """
+    registration = registry.get_function_group(type(config))
+
+    function_frameworks = detect_llm_frameworks_in_build_fn(registration)
+    build_fn = chain_wrapped_build_fn(registration.build_fn, llms, function_frameworks)
+
+    build_result = await exit_stack.enter_async_context(build_fn(config, inner_builder))
+
+    dependencies[name] = inner_builder.dependencies
+
+    if not isinstance(build_result, FunctionGroup):
+        raise ValueError("Expected a FunctionGroup object to be returned from the function group builder. "
+                         f"Got {type(build_result)}")
+
+    # Set the instance name BEFORE configuring middleware
+    build_result.set_instance_name(name)
+    build_result.configure_middleware(middleware_instances)
+
+    return ConfiguredFunctionGroup(config=config, instance=build_result)
+
+
 class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
     def __init__(self, *, general_config: GeneralConfig | None = None, registry: TypeRegistry | None = None):
@@ -170,6 +335,10 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         self._object_stores: dict[str, ConfiguredObjectStore] = {}
         self._retrievers: dict[str, ConfiguredRetriever] = {}
         self._ttc_strategies: dict[str, ConfiguredTTCStrategy] = {}
+        self._middleware: dict[str, ConfiguredMiddleware] = {}
+        self._trainers: dict[str, ConfiguredTrainer] = {}
+        self._trainer_adapters: dict[str, ConfiguredTrainerAdapter] = {}
+        self._trajectory_builders: dict[str, ConfiguredTrajectoryBuilder] = {}
 
         self._context_state = ContextState.get()
 
@@ -178,8 +347,11 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         # Create a mapping to track function name -> other function names it depends on
         self.function_dependencies: dict[str, FunctionDependencies] = {}
         self.function_group_dependencies: dict[str, FunctionDependencies] = {}
-        self.current_function_building: str | None = None
-        self.current_function_group_building: str | None = None
+
+        # List of completed built components
+        self.completed_components: list[tuple[str, str]] = []
+        # List of remaining components to be built
+        self.remaining_components: list[tuple[str, str]] = []
 
     async def __aenter__(self):
 
@@ -260,6 +432,11 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         await self._exit_stack.__aexit__(*exc_details)
 
+    @override
+    @property
+    def sync_builder(self) -> SyncBuilder:
+        return SyncBuilder(self)
+
     async def build(self, entry_function: str | None = None) -> Workflow:
         """
         Creates an instance of a workflow object using the added components and the desired entry function.
@@ -334,6 +511,18 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
                         ttc_strategies={
                             k: v.config
                             for k, v in self._ttc_strategies.items()
+                        },
+                        trainers={
+                            k: v.config
+                            for k, v in self._trainers.items()
+                        },
+                        trainer_adapters={
+                            k: v.config
+                            for k, v in self._trainer_adapters.items()
+                        },
+                        trajectory_builders={
+                            k: v.config
+                            for k, v in self._trajectory_builders.items()
                         })
 
         if (entry_function is None):
@@ -385,45 +574,49 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         return self._exit_stack
 
-    async def _build_function(self, name: str, config: FunctionBaseConfig) -> ConfiguredFunction:
-        registration = self._registry.get_function(type(config))
-
-        inner_builder = ChildBuilder(self)
-
-        # We need to do this for every function because we don't know
-        # Where LLama Index Agents are Instantiated and Settings need to
-        # be set before the function is built
-        # It's only slower the first time because of the import
-        # So we can afford to do this for every function
-
-        llms = {k: v.instance for k, v in self._llms.items()}
-        function_frameworks = detect_llm_frameworks_in_build_fn(registration)
-
-        build_fn = chain_wrapped_build_fn(registration.build_fn, llms, function_frameworks)
-
-        # Set the currently building function so the ChildBuilder can track dependencies
-        self.current_function_building = config.type
-        # Empty set of dependencies for the current function
-        self.function_dependencies[config.type] = FunctionDependencies()
-
-        build_result = await self._get_exit_stack().enter_async_context(build_fn(config, inner_builder))
-
-        self.function_dependencies[name] = inner_builder.dependencies
-
-        # If the build result is a function, wrap it in a FunctionInfo
-        if inspect.isfunction(build_result):
-
-            build_result = FunctionInfo.from_fn(build_result)
-
-        if (isinstance(build_result, FunctionInfo)):
-            # Create the function object
-            build_result = LambdaFunction.from_info(config=config, info=build_result, instance_name=name)
+    async def _resolve_middleware_instances(self, middleware_names: list[str], component_name: str,
+                                            component_type: str) -> list[FunctionMiddleware]:
+        """
+        Resolve middleware names to FunctionMiddleware instances.
+        """
 
-        if (not isinstance(build_result, Function)):
-            raise ValueError("Expected a function, FunctionInfo object, or FunctionBase object to be "
-                             f"returned from the function builder. Got {type(build_result)}")
+        middleware_instances: list[FunctionMiddleware] = []
+        for middleware_name in middleware_names:
+            if middleware_name not in self._middleware:
+                raise ValueError(f"Middleware `{middleware_name}` not found for {component_type} `{component_name}`. "
+                                 f"It must be configured in the `middleware` section of the YAML configuration.")
+            middleware_obj = self._middleware[middleware_name].instance
+            if not isinstance(middleware_obj, FunctionMiddleware):
+                raise TypeError(f"Middleware `{middleware_name}` is not a FunctionMiddleware and cannot be used"
+                                f"with {component_type}s. "
+                                f"Only FunctionMiddleware types support function-specific wrapping.")
+            middleware_instances.append(middleware_obj)
+        return middleware_instances
 
-        return ConfiguredFunction(config=config, instance=build_result)
+    async def _build_function(self, name: str, config: FunctionBaseConfig) -> ConfiguredFunction:
+        with ChildBuilder.use(config, self) as inner_builder:
+
+            # We need to do this for every function because we don't know
+            # Where LLama Index Agents are Instantiated and Settings need to
+            # be set before the function is built
+            # It's only slower the first time because of the import
+            # So we can afford to do this for every function
+            llms = {k: v.instance for k, v in self._llms.items()}
+
+            # Resolve middleware names from config to middleware instances
+            # Only FunctionMiddleware types can be used with functions
+            middleware_instances = await self._resolve_middleware_instances(config.middleware, name, "function")
+
+            return await _build_function_impl(
+                name=name,
+                config=config,
+                registry=self._registry,
+                exit_stack=self._get_exit_stack(),
+                inner_builder=inner_builder,
+                llms=llms,
+                dependencies=self.function_dependencies,
+                middleware_instances=middleware_instances,
+            )
 
     async def _build_function_group(self, name: str, config: FunctionGroupBaseConfig) -> ConfiguredFunctionGroup:
         """Build a function group from the provided configuration.
@@ -438,32 +631,23 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         Raises:
             ValueError: If the function group builder returns invalid results
         """
-        registration = self._registry.get_function_group(type(config))
-
-        inner_builder = ChildBuilder(self)
 
-        # Build the function group - use the same wrapping pattern as _build_function
-        llms = {k: v.instance for k, v in self._llms.items()}
-        function_frameworks = detect_llm_frameworks_in_build_fn(registration)
+        with ChildBuilder.use(config, self) as inner_builder:
 
-        build_fn = chain_wrapped_build_fn(registration.build_fn, llms, function_frameworks)
+            # Build the function group - use the same wrapping pattern as _build_function
+            llms = {k: v.instance for k, v in self._llms.items()}
+            # Resolve middleware names from config to middleware instances
+            # Only FunctionMiddleware types can be used with function groups
+            middleware_instances = await self._resolve_middleware_instances(config.middleware, name, "function group")
 
-        # Set the currently building function group so the ChildBuilder can track dependencies
-        self.current_function_group_building = config.type
-        # Empty set of dependencies for the current function group
-        self.function_group_dependencies[config.type] = FunctionDependencies()
-
-        build_result = await self._get_exit_stack().enter_async_context(build_fn(config, inner_builder))
-
-        self.function_group_dependencies[name] = inner_builder.dependencies
-
-        if not isinstance(build_result, FunctionGroup):
-            raise ValueError("Expected a FunctionGroup object to be returned from the function group builder. "
-                             f"Got {type(build_result)}")
-
-        # set the instance name for the function group based on the workflow-provided name
-        build_result.set_instance_name(name)
-        return ConfiguredFunctionGroup(config=config, instance=build_result)
+            return await _build_function_group_impl(name=name,
+                                                    config=config,
+                                                    registry=self._registry,
+                                                    exit_stack=self._get_exit_stack(),
+                                                    inner_builder=inner_builder,
+                                                    llms=llms,
+                                                    dependencies=self.function_group_dependencies,
+                                                    middleware_instances=middleware_instances)
 
     @override
     async def add_function(self, name: str | FunctionRef, config: FunctionBaseConfig) -> Function:
@@ -472,6 +656,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         if (name in self._functions or name in self._function_groups):
             raise ValueError(f"Function `{name}` already exists in the list of functions or function groups")
+        if any(name.startswith(k + FunctionGroup.SEPARATOR) for k in self._function_groups.keys()):
+            raise ValueError(f"A Function name starts with a Function Group name: `{name}`")
 
         build_result = await self._build_function(name=name, config=config)
 
@@ -486,6 +672,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         if (name in self._function_groups or name in self._functions):
             raise ValueError(f"Function group `{name}` already exists in the list of function groups or functions")
+        if any(k.startswith(name + FunctionGroup.SEPARATOR) for k in self._functions.keys()):
+            raise ValueError(f"A Function name starts with a Function Group name: `{name}`")
 
         # Build the function group
         build_result = await self._build_function_group(name=name, config=config)
@@ -505,10 +693,23 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         return build_result.instance
 
+    def _check_backwards_compatibility_function_name(self, name: str) -> str:
+        if name in self._functions:
+            return name
+        new_name = name.replace(FunctionGroup.LEGACY_SEPARATOR, FunctionGroup.SEPARATOR)
+        if new_name in self._functions:
+            logger.warning(
+                f"Function `{name}` is deprecated and will be removed in a future release. Use `{new_name}` instead.")
+            return new_name
+        return name
+
     @override
     async def get_function(self, name: str | FunctionRef) -> Function:
         if isinstance(name, FunctionRef):
             name = str(name)
+
+        name = self._check_backwards_compatibility_function_name(name)
+
         if name not in self._functions:
             raise ValueError(f"Function `{name}` not found")
 
@@ -527,6 +728,7 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
     def get_function_config(self, name: str | FunctionRef) -> FunctionBaseConfig:
         if isinstance(name, FunctionRef):
             name = str(name)
+        name = self._check_backwards_compatibility_function_name(name)
         if name not in self._functions:
             raise ValueError(f"Function `{name}` not found")
 
@@ -547,7 +749,7 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         if self._workflow is not None:
             warnings.warn("Overwriting existing workflow")
 
-        build_result = await self._build_function(name="<workflow>", config=config)
+        build_result = await self._build_function(name=WORKFLOW_COMPONENT_NAME, config=config)
 
         self._workflow = build_result
 
@@ -618,6 +820,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
     async def get_tool(self, fn_name: str | FunctionRef, wrapper_type: LLMFrameworkEnum | str) -> typing.Any:
         if isinstance(fn_name, FunctionRef):
             fn_name = str(fn_name)
+
+        fn_name = self._check_backwards_compatibility_function_name(fn_name)
+
         if fn_name not in self._functions:
             raise ValueError(f"Function `{fn_name}` not found in list of functions")
         fn = self._functions[fn_name]
@@ -640,9 +845,10 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         try:
             llm_info = self._registry.get_llm_provider(type(config))
 
-            info_obj = await self._get_exit_stack().enter_async_context(llm_info.build_fn(config, self))
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(llm_info.build_fn(config, inner_builder))
 
-            self._llms[name] = ConfiguredLLM(config=config, instance=info_obj)
+                self._llms[name] = ConfiguredLLM(config=config, instance=info_obj)
         except Exception as e:
             logger.error("Error adding llm `%s` with config `%s`: %s", name, config, e)
             raise
@@ -660,7 +866,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Generate wrapped client from registered client info
             client_info = self._registry.get_llm_client(config_type=type(llm_info.config), wrapper_type=wrapper_type)
 
-            client = await self._get_exit_stack().enter_async_context(client_info.build_fn(llm_info.config, self))
+            with ChildBuilder.use(llm_info.config, self) as inner_builder:
+                client = await self._get_exit_stack().enter_async_context(
+                    client_info.build_fn(llm_info.config, inner_builder))
 
             # Return a frameworks specific client
             return client
@@ -710,7 +918,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         try:
             authentication_info = self._registry.get_auth_provider(type(config))
 
-            info_obj = await self._get_exit_stack().enter_async_context(authentication_info.build_fn(config, self))
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(
+                    authentication_info.build_fn(config, inner_builder))
 
             self._auth_providers[name] = ConfiguredAuthProvider(config=config, instance=info_obj)
 
@@ -756,7 +966,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         try:
             embedder_info = self._registry.get_embedder_provider(type(config))
 
-            info_obj = await self._get_exit_stack().enter_async_context(embedder_info.build_fn(config, self))
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(
+                    embedder_info.build_fn(config, inner_builder))
 
             self._embedders[name] = ConfiguredEmbedder(config=config, instance=info_obj)
         except Exception as e:
@@ -776,7 +988,10 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Generate wrapped client from registered client info
             client_info = self._registry.get_embedder_client(config_type=type(embedder_info.config),
                                                              wrapper_type=wrapper_type)
-            client = await self._get_exit_stack().enter_async_context(client_info.build_fn(embedder_info.config, self))
+
+            with ChildBuilder.use(embedder_info.config, self) as inner_builder:
+                client = await self._get_exit_stack().enter_async_context(
+                    client_info.build_fn(embedder_info.config, inner_builder))
 
             # Return a frameworks specific client
             return client
@@ -801,7 +1016,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         memory_info = self._registry.get_memory(type(config))
 
-        info_obj = await self._get_exit_stack().enter_async_context(memory_info.build_fn(config, self))
+        with ChildBuilder.use(config, self) as inner_builder:
+            info_obj = await self._get_exit_stack().enter_async_context(memory_info.build_fn(config, inner_builder))
 
         self._memory_clients[name] = ConfiguredMemory(config=config, instance=info_obj)
 
@@ -833,7 +1049,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         object_store_info = self._registry.get_object_store(type(config))
 
-        info_obj = await self._get_exit_stack().enter_async_context(object_store_info.build_fn(config, self))
+        with ChildBuilder.use(config, self) as inner_builder:
+            info_obj = await self._get_exit_stack().enter_async_context(
+                object_store_info.build_fn(config, inner_builder))
 
         self._object_stores[name] = ConfiguredObjectStore(config=config, instance=info_obj)
 
@@ -862,7 +1080,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         try:
             retriever_info = self._registry.get_retriever_provider(type(config))
 
-            info_obj = await self._get_exit_stack().enter_async_context(retriever_info.build_fn(config, self))
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(
+                    retriever_info.build_fn(config, inner_builder))
 
             self._retrievers[name] = ConfiguredRetriever(config=config, instance=info_obj)
 
@@ -886,7 +1106,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             client_info = self._registry.get_retriever_client(config_type=type(retriever_info.config),
                                                               wrapper_type=wrapper_type)
 
-            client = await self._get_exit_stack().enter_async_context(client_info.build_fn(retriever_info.config, self))
+            with ChildBuilder.use(retriever_info.config, self) as inner_builder:
+                client = await self._get_exit_stack().enter_async_context(
+                    client_info.build_fn(retriever_info.config, inner_builder))
 
             # Return a frameworks specific client
             return client
@@ -902,6 +1124,120 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
         return self._retrievers[retriever_name].config
 
+    @override
+    @experimental(feature_name="Finetuning")
+    async def add_trainer(self, name: str | TrainerRef, config: TrainerConfig) -> Trainer:
+        if (name in self._trainers):
+            raise ValueError(f"Trainer '{name}' already exists in the list of trainers")
+
+        try:
+            trainer_info = self._registry.get_trainer(type(config))
+
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(trainer_info.build_fn(
+                    config, inner_builder))
+
+            self._trainers[name] = ConfiguredTrainer(config=config, instance=info_obj)
+
+            return info_obj
+
+        except Exception as e:
+            logger.error("Error adding trainer `%s` with config `%s`: %s", name, config, e)
+            raise
+
+    @override
+    @experimental(feature_name="Finetuning")
+    async def add_trainer_adapter(self, name: str | TrainerAdapterRef, config: TrainerAdapterConfig) -> TrainerAdapter:
+        if (name in self._trainer_adapters):
+            raise ValueError(f"Trainer adapter '{name}' already exists in the list of trainer adapters")
+
+        try:
+            trainer_adapter_info = self._registry.get_trainer_adapter(type(config))
+
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(
+                    trainer_adapter_info.build_fn(config, inner_builder))
+
+            self._trainer_adapters[name] = ConfiguredTrainerAdapter(config=config, instance=info_obj)
+
+            return info_obj
+
+        except Exception as e:
+            logger.error("Error adding trainer adapter `%s` with config `%s`: %s", name, config, e)
+            raise
+
+    @override
+    @experimental(feature_name="Finetuning")
+    async def add_trajectory_builder(self, name: str | TrajectoryBuilderRef,
+                                     config: TrajectoryBuilderConfig) -> TrajectoryBuilder:
+        if (name in self._trajectory_builders):
+            raise ValueError(f"Trajectory builder '{name}' already exists in the list of trajectory builders")
+
+        try:
+            trajectory_builder_info = self._registry.get_trajectory_builder(type(config))
+
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(
+                    trajectory_builder_info.build_fn(config, inner_builder))
+
+            self._trajectory_builders[name] = ConfiguredTrajectoryBuilder(config=config, instance=info_obj)
+
+            return info_obj
+
+        except Exception as e:
+            logger.error("Error adding trajectory builder `%s` with config `%s`: %s", name, config, e)
+            raise
+
+    @override
+    async def get_trainer(self,
+                          trainer_name: str | TrainerRef,
+                          trajectory_builder: TrajectoryBuilder,
+                          trainer_adapter: TrainerAdapter) -> Trainer:
+
+        if trainer_name not in self._trainers:
+            raise ValueError(f"Trainer '{trainer_name}' not found")
+
+        trainer_instance = self._trainers[trainer_name].instance
+        await trainer_instance.bind_components(trainer_adapter=trainer_adapter, trajectory_builder=trajectory_builder)
+
+        return trainer_instance
+
+    @override
+    async def get_trainer_config(self, trainer_name: str | TrainerRef) -> TrainerConfig:
+        if trainer_name not in self._trainers:
+            raise ValueError(f"Trainer '{trainer_name}' not found")
+
+        return self._trainers[trainer_name].config
+
+    @override
+    async def get_trainer_adapter_config(self, trainer_adapter_name: str | TrainerAdapterRef) -> TrainerAdapterConfig:
+        if trainer_adapter_name not in self._trainer_adapters:
+            raise ValueError(f"Trainer adapter '{trainer_adapter_name}' not found")
+
+        return self._trainer_adapters[trainer_adapter_name].config
+
+    @override
+    async def get_trajectory_builder_config(
+            self, trajectory_builder_name: str | TrajectoryBuilderRef) -> (TrajectoryBuilderConfig):
+        if trajectory_builder_name not in self._trajectory_builders:
+            raise ValueError(f"Trajectory builder '{trajectory_builder_name}' not found")
+
+        return self._trajectory_builders[trajectory_builder_name].config
+
+    @override
+    async def get_trainer_adapter(self, trainer_adapter_name: str | TrainerAdapterRef) -> TrainerAdapter:
+        if trainer_adapter_name not in self._trainer_adapters:
+            raise ValueError(f"Trainer adapter '{trainer_adapter_name}' not found")
+
+        return self._trainer_adapters[trainer_adapter_name].instance
+
+    @override
+    async def get_trajectory_builder(self, trajectory_builder_name: str | TrajectoryBuilderRef) -> TrajectoryBuilder:
+        if trajectory_builder_name not in self._trajectory_builders:
+            raise ValueError(f"Trajectory builder '{trajectory_builder_name}' not found")
+
+        return self._trajectory_builders[trajectory_builder_name].instance
+
     @override
     @experimental(feature_name="TTC")
     async def add_ttc_strategy(self, name: str | TTCStrategyRef, config: TTCStrategyBaseConfig) -> None:
@@ -911,7 +1247,9 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         try:
             ttc_strategy_info = self._registry.get_ttc_strategy(type(config))
 
-            info_obj = await self._get_exit_stack().enter_async_context(ttc_strategy_info.build_fn(config, self))
+            with ChildBuilder.use(config, self) as inner_builder:
+                info_obj = await self._get_exit_stack().enter_async_context(
+                    ttc_strategy_info.build_fn(config, inner_builder))
 
             self._ttc_strategies[name] = ConfiguredTTCStrategy(config=config, instance=info_obj)
 
@@ -969,98 +1307,96 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         return config
 
     @override
-    def get_user_manager(self):
-        return UserManagerHolder(context=Context(self._context_state))
-
-    async def add_telemetry_exporter(self, name: str, config: TelemetryExporterBaseConfig) -> None:
-        """Add an configured telemetry exporter to the builder.
+    async def add_middleware(self, name: str | MiddlewareRef, config: MiddlewareBaseConfig) -> Middleware:
+        """Add middleware to the builder.
 
         Args:
-            name (str): The name of the telemetry exporter
-            config (TelemetryExporterBaseConfig): The configuration for the exporter
+            name: The name or reference for the middleware
+            config: The configuration for the middleware
+
+        Returns:
+            The built middleware instance
+
+        Raises:
+            ValueError: If the middleware already exists
         """
-        if (name in self._telemetry_exporters):
-            raise ValueError(f"Telemetry exporter '{name}' already exists in the list of telemetry exporters")
+        if name in self._middleware:
+            raise ValueError(f"Middleware `{name}` already exists in the list of middleware")
 
-        exporter_info = self._registry.get_telemetry_exporter(type(config))
+        try:
+            middleware_info = self._registry.get_middleware(type(config))
 
-        # Build the exporter outside the lock (parallel)
-        exporter_context_manager = exporter_info.build_fn(config, self)
+            with ChildBuilder.use(config, self) as inner_builder:
+                middleware_instance = await self._get_exit_stack().enter_async_context(
+                    middleware_info.build_fn(config, inner_builder))
 
-        # Only protect the shared state modifications (serialized)
-        exporter = await self._get_exit_stack().enter_async_context(exporter_context_manager)
-        self._telemetry_exporters[name] = ConfiguredTelemetryExporter(config=config, instance=exporter)
+            self._middleware[name] = ConfiguredMiddleware(config=config, instance=middleware_instance)
 
-    def _log_build_failure(self,
-                           component_name: str,
-                           component_type: str,
-                           completed_components: list[tuple[str, str]],
-                           remaining_components: list[tuple[str, str]],
-                           original_error: Exception) -> None:
-        """
-        Common method to log comprehensive build failure information.
+            return middleware_instance
+        except Exception as e:
+            logger.error("Error adding function middleware `%s` with config `%s`: %s", name, config, e)
+            raise
+
+    @override
+    async def get_middleware(self, middleware_name: str | MiddlewareRef) -> Middleware:
+        """Get built middleware by name.
 
         Args:
-            component_name (str): The name of the component that failed to build
-            component_type (str): The type of the component that failed to build
-            completed_components (list[tuple[str, str]]): List of (name, type) tuples for successfully built components
-            remaining_components (list[tuple[str, str]]): List of (name, type) tuples for components still to be built
-            original_error (Exception): The original exception that caused the failure
-        """
-        logger.error("Failed to initialize component %s (%s)", component_name, component_type)
+            middleware_name: The name or reference of the middleware
 
-        if completed_components:
-            logger.error("Successfully built components:")
-            for name, comp_type in completed_components:
-                logger.error("- %s (%s)", name, comp_type)
-        else:
-            logger.error("No components were successfully built before this failure")
+        Returns:
+            The built middleware instance
 
-        if remaining_components:
-            logger.error("Remaining components to build:")
-            for name, comp_type in remaining_components:
-                logger.error("- %s (%s)", name, comp_type)
-        else:
-            logger.error("No remaining components to build")
+        Raises:
+            ValueError: If the middleware is not found
+        """
+        if middleware_name not in self._middleware:
+            raise ValueError(f"Middleware `{middleware_name}` not found")
 
-        logger.error("Original error: %s", original_error, exc_info=True)
+        return self._middleware[middleware_name].instance
 
-    def _log_build_failure_component(self,
-                                     failing_component: ComponentInstanceData,
-                                     completed_components: list[tuple[str, str]],
-                                     remaining_components: list[tuple[str, str]],
-                                     original_error: Exception) -> None:
-        """
-        Log comprehensive component build failure information.
+    @override
+    def get_middleware_config(self, middleware_name: str | MiddlewareRef) -> MiddlewareBaseConfig:
+        """Get the configuration for middleware.
 
         Args:
-            failing_component (ComponentInstanceData): The ComponentInstanceData that failed to build
-            completed_components (list[tuple[str, str]]): List of (name, type) tuples for successfully built components
-            remaining_components (list[tuple[str, str]]): List of (name, type) tuples for components still to be built
-            original_error (Exception): The original exception that caused the failure
-        """
-        component_name = failing_component.name
-        component_type = failing_component.component_group.value
-
-        self._log_build_failure(component_name,
-                                component_type,
-                                completed_components,
-                                remaining_components,
-                                original_error)
-
-    def _log_build_failure_workflow(self,
-                                    completed_components: list[tuple[str, str]],
-                                    remaining_components: list[tuple[str, str]],
-                                    original_error: Exception) -> None:
+            middleware_name: The name or reference of the middleware
+
+        Returns:
+            The configuration for the middleware
+
+        Raises:
+            ValueError: If the middleware is not found
         """
-        Log comprehensive workflow build failure information.
+        if middleware_name not in self._middleware:
+            raise ValueError(f"Middleware `{middleware_name}` not found")
+
+        return self._middleware[middleware_name].config
+
+    @override
+    def get_user_manager(self):
+        return UserManagerHolder(context=Context(self._context_state))
+
+    async def add_telemetry_exporter(self, name: str, config: TelemetryExporterBaseConfig) -> None:
+        """Add an configured telemetry exporter to the builder.
 
         Args:
-            completed_components (list[tuple[str, str]]): List of (name, type) tuples for successfully built components
-            remaining_components (list[tuple[str, str]]): List of (name, type) tuples for components still to be built
-            original_error (Exception): The original exception that caused the failure
+            name (str): The name of the telemetry exporter
+            config (TelemetryExporterBaseConfig): The configuration for the exporter
         """
-        self._log_build_failure("<workflow>", "workflow", completed_components, remaining_components, original_error)
+        if (name in self._telemetry_exporters):
+            raise ValueError(f"Telemetry exporter '{name}' already exists in the list of telemetry exporters")
+
+        exporter_info = self._registry.get_telemetry_exporter(type(config))
+
+        # Build the exporter outside the lock (parallel)
+        with ChildBuilder.use(config, self) as inner_builder:
+            exporter_context_manager = exporter_info.build_fn(config, inner_builder)
+
+            # Only protect the shared state modifications (serialized)
+            exporter = await self._get_exit_stack().enter_async_context(exporter_context_manager)
+
+        self._telemetry_exporters[name] = ConfiguredTelemetryExporter(config=config, instance=exporter)
 
     async def populate_builder(self, config: Config, skip_workflow: bool = False):
         """
@@ -1074,21 +1410,14 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         # Generate the build sequence
         build_sequence = build_dependency_sequence(config)
 
-        # Initialize progress tracking
-        completed_components = []
-        remaining_components = [(str(comp.name), comp.component_group.value) for comp in build_sequence
-                                if not comp.is_root]
+        self.remaining_components = [(str(comp.name), comp.component_group.value) for comp in build_sequence
+                                     if not comp.is_root]
         if not skip_workflow:
-            remaining_components.append(("<workflow>", "workflow"))
+            self.remaining_components.append((WORKFLOW_COMPONENT_NAME, "workflow"))
 
-        # Loop over all objects and add to the workflow builder
+        # Loop over all components and add to the workflow builder
         for component_instance in build_sequence:
             try:
-                # Remove from remaining as we start building (if not root)
-                if not component_instance.is_root:
-                    remaining_components.remove(
-                        (str(component_instance.name), component_instance.component_group.value))
-
                 # Instantiate a the llm
                 if component_instance.component_group == ComponentGroup.LLMS:
                     await self.add_llm(component_instance.name, cast(LLMBaseConfig, component_instance.config))
@@ -1108,16 +1437,29 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
                 elif component_instance.component_group == ComponentGroup.RETRIEVERS:
                     await self.add_retriever(component_instance.name,
                                              cast(RetrieverBaseConfig, component_instance.config))
+                # Instantiate middleware
+                elif component_instance.component_group == ComponentGroup.MIDDLEWARE:
+                    await self.add_middleware(component_instance.name,
+                                              cast(MiddlewareBaseConfig, component_instance.config))
                 # Instantiate a function group
                 elif component_instance.component_group == ComponentGroup.FUNCTION_GROUPS:
+                    config_obj = cast(FunctionGroupBaseConfig, component_instance.config)
+                    registration = self._registry.get_function_group(type(config_obj))
+                    if registration.is_per_user:
+                        # Skip per-user function groups as they will be built lazily by PerUserWorkflowBuilder
+                        continue
                     await self.add_function_group(component_instance.name,
                                                   cast(FunctionGroupBaseConfig, component_instance.config))
                 # Instantiate a function
                 elif component_instance.component_group == ComponentGroup.FUNCTIONS:
-                    # If the function is the root, set it as the workflow later
-                    if (not component_instance.is_root):
-                        await self.add_function(component_instance.name,
-                                                cast(FunctionBaseConfig, component_instance.config))
+                    config_obj = cast(FunctionBaseConfig, component_instance.config)
+                    registration = self._registry.get_function(type(config_obj))
+                    if registration.is_per_user:
+                        # Skip per-user functions as they will be built lazily by PerUserWorkflowBuilder
+                        continue
+                    elif not component_instance.is_root:
+                        # If the function is not the root, add it to the workflow builder
+                        await self.add_function(component_instance.name, config_obj)
                 elif component_instance.component_group == ComponentGroup.TTC_STRATEGIES:
                     await self.add_ttc_strategy(component_instance.name,
                                                 cast(TTCStrategyBaseConfig, component_instance.config))
@@ -1125,241 +1467,140 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
                 elif component_instance.component_group == ComponentGroup.AUTHENTICATION:
                     await self.add_auth_provider(component_instance.name,
                                                  cast(AuthProviderBaseConfig, component_instance.config))
+
+                elif component_instance.component_group == ComponentGroup.TRAINERS:
+                    await self.add_trainer(component_instance.name, cast(TrainerConfig, component_instance.config))
+
+                elif component_instance.component_group == ComponentGroup.TRAINER_ADAPTERS:
+                    await self.add_trainer_adapter(component_instance.name,
+                                                   cast(TrainerAdapterConfig, component_instance.config))
+
+                elif component_instance.component_group == ComponentGroup.TRAJECTORY_BUILDERS:
+                    await self.add_trajectory_builder(component_instance.name,
+                                                      cast(TrajectoryBuilderConfig, component_instance.config))
                 else:
                     raise ValueError(f"Unknown component group {component_instance.component_group}")
 
-                # Add to completed after successful build (if not root)
+                # Remove from remaining and add to completed after successful build (if not root)
                 if not component_instance.is_root:
-                    completed_components.append(
+                    self.remaining_components.remove(
+                        (str(component_instance.name), component_instance.component_group.value))
+                    self.completed_components.append(
                         (str(component_instance.name), component_instance.component_group.value))
 
             except Exception as e:
-                self._log_build_failure_component(component_instance, completed_components, remaining_components, e)
+                _log_build_failure(str(component_instance.name),
+                                   component_instance.component_group.value,
+                                   self.completed_components,
+                                   self.remaining_components,
+                                   e)
                 raise
 
         # Instantiate the workflow
         if not skip_workflow:
             try:
-                # Remove workflow from remaining as we start building
-                remaining_components.remove(("<workflow>", "workflow"))
-                await self.set_workflow(config.workflow)
-                completed_components.append(("<workflow>", "workflow"))
+                workflow_registration = self._registry.get_function(type(config.workflow))
+                # If the workflow is shared (not per-user), build it
+                # Otherwise, build it lazily by PerUserWorkflowBuilder
+                if not workflow_registration.is_per_user:
+                    # Remove workflow from remaining as we start building
+                    self.remaining_components.remove((WORKFLOW_COMPONENT_NAME, "workflow"))
+                    await self.set_workflow(config.workflow)
+                    self.completed_components.append((WORKFLOW_COMPONENT_NAME, "workflow"))
             except Exception as e:
-                self._log_build_failure_workflow(completed_components, remaining_components, e)
+                _log_build_failure(WORKFLOW_COMPONENT_NAME,
+                                   "workflow",
+                                   self.completed_components,
+                                   self.remaining_components,
+                                   e)
                 raise
 
-    @classmethod
-    @asynccontextmanager
-    async def from_config(cls, config: Config):
-
-        async with cls(general_config=config.general) as builder:
-            await builder.populate_builder(config)
-            yield builder
-
-
-class ChildBuilder(Builder):
-
-    def __init__(self, workflow_builder: WorkflowBuilder) -> None:
-
-        self._workflow_builder = workflow_builder
-
-        self._dependencies = FunctionDependencies()
-
-    @property
-    def dependencies(self) -> FunctionDependencies:
-        return self._dependencies
-
-    @override
-    async def add_function(self, name: str, config: FunctionBaseConfig) -> Function:
-        return await self._workflow_builder.add_function(name, config)
-
-    @override
-    async def add_function_group(self, name: str, config: FunctionGroupBaseConfig) -> FunctionGroup:
-        return await self._workflow_builder.add_function_group(name, config)
-
-    @override
-    async def get_function(self, name: str) -> Function:
-        # If a function tries to get another function, we assume it uses it
-        fn = await self._workflow_builder.get_function(name)
-
-        self._dependencies.add_function(name)
-
-        return fn
-
-    @override
-    async def get_function_group(self, name: str) -> FunctionGroup:
-        # If a function tries to get a function group, we assume it uses it
-        function_group = await self._workflow_builder.get_function_group(name)
-
-        self._dependencies.add_function_group(name)
-
-        return function_group
-
-    @override
-    def get_function_config(self, name: str) -> FunctionBaseConfig:
-        return self._workflow_builder.get_function_config(name)
-
-    @override
-    def get_function_group_config(self, name: str) -> FunctionGroupBaseConfig:
-        return self._workflow_builder.get_function_group_config(name)
-
-    @override
-    async def set_workflow(self, config: FunctionBaseConfig) -> Function:
-        return await self._workflow_builder.set_workflow(config)
-
-    @override
-    def get_workflow(self) -> Function:
-        return self._workflow_builder.get_workflow()
-
-    @override
-    def get_workflow_config(self) -> FunctionBaseConfig:
-        return self._workflow_builder.get_workflow_config()
-
-    @override
-    async def get_tools(self,
-                        tool_names: Sequence[str | FunctionRef | FunctionGroupRef],
-                        wrapper_type: LLMFrameworkEnum | str) -> list[typing.Any]:
-        tools = await self._workflow_builder.get_tools(tool_names, wrapper_type)
-        for tool_name in tool_names:
-            if tool_name in self._workflow_builder._function_groups:
-                self._dependencies.add_function_group(tool_name)
-            else:
-                self._dependencies.add_function(tool_name)
-        return tools
-
-    @override
-    async def get_tool(self, fn_name: str | FunctionRef, wrapper_type: LLMFrameworkEnum | str):
-        # If a function tries to get another function as a tool, we assume it uses it
-        fn = await self._workflow_builder.get_tool(fn_name, wrapper_type)
-
-        self._dependencies.add_function(fn_name)
-
-        return fn
-
-    @override
-    async def add_llm(self, name: str, config: LLMBaseConfig) -> None:
-        return await self._workflow_builder.add_llm(name, config)
-
-    @experimental(feature_name="Authentication")
-    @override
-    async def add_auth_provider(self, name: str, config: AuthProviderBaseConfig) -> AuthProviderBase:
-        return await self._workflow_builder.add_auth_provider(name, config)
-
-    @override
-    async def get_auth_provider(self, auth_provider_name: str):
-        return await self._workflow_builder.get_auth_provider(auth_provider_name)
-
-    @override
-    async def get_llm(self, llm_name: str, wrapper_type: LLMFrameworkEnum | str) -> typing.Any:
-        llm = await self._workflow_builder.get_llm(llm_name, wrapper_type)
-
-        self._dependencies.add_llm(llm_name)
-
-        return llm
+        # Check if any shared components have dependencies on per-user components
+        self._validate_dependencies(config)
 
-    @override
-    def get_llm_config(self, llm_name: str) -> LLMBaseConfig:
-        return self._workflow_builder.get_llm_config(llm_name)
-
-    @override
-    async def add_embedder(self, name: str, config: EmbedderBaseConfig) -> None:
-        await self._workflow_builder.add_embedder(name, config)
-
-    @override
-    async def get_embedder(self, embedder_name: str, wrapper_type: LLMFrameworkEnum | str) -> typing.Any:
-        embedder = await self._workflow_builder.get_embedder(embedder_name, wrapper_type)
-
-        self._dependencies.add_embedder(embedder_name)
-
-        return embedder
-
-    @override
-    def get_embedder_config(self, embedder_name: str) -> EmbedderBaseConfig:
-        return self._workflow_builder.get_embedder_config(embedder_name)
-
-    @override
-    async def add_memory_client(self, name: str, config: MemoryBaseConfig) -> MemoryEditor:
-        return await self._workflow_builder.add_memory_client(name, config)
-
-    @override
-    async def get_memory_client(self, memory_name: str) -> MemoryEditor:
-        """
-        Return the instantiated memory client for the given name.
+    def _validate_dependencies(self, config: Config):
         """
-        memory_client = await self._workflow_builder.get_memory_client(memory_name)
-
-        self._dependencies.add_memory_client(memory_name)
-
-        return memory_client
-
-    @override
-    def get_memory_client_config(self, memory_name: str) -> MemoryBaseConfig:
-        return self._workflow_builder.get_memory_client_config(memory_name=memory_name)
+        Validate no shared component has dependencies on any per-user components.
 
-    @override
-    async def add_object_store(self, name: str, config: ObjectStoreBaseConfig):
-        return await self._workflow_builder.add_object_store(name, config)
-
-    @override
-    async def get_object_store_client(self, object_store_name: str) -> ObjectStore:
+        This prevents invalid configurations where shared components try to use per-user functions that do not exist
+        at shared builder initialization time.
         """
-        Return the instantiated object store client for the given name.
-        """
-        object_store_client = await self._workflow_builder.get_object_store_client(object_store_name)
-
-        self._dependencies.add_object_store(object_store_name)
 
-        return object_store_client
-
-    @override
-    def get_object_store_config(self, object_store_name: str) -> ObjectStoreBaseConfig:
-        return self._workflow_builder.get_object_store_config(object_store_name)
-
-    @override
-    @experimental(feature_name="TTC")
-    async def add_ttc_strategy(self, name: str, config: TTCStrategyBaseConfig) -> None:
-        await self._workflow_builder.add_ttc_strategy(name, config)
+        # Check shared functions do not depend on per-user functions or function_groups
+        for fn_name, fn_deps in self.function_dependencies.items():
+            if fn_name == WORKFLOW_COMPONENT_NAME:
+                continue
+
+            fn_config = self.get_function_config(fn_name)
+            fn_registration = self._registry.get_function(type(fn_config))
+
+            if not fn_registration.is_per_user:
+                for dep_fn_name in fn_deps.functions:
+                    dep_config = config.functions.get(dep_fn_name)
+                    if dep_config is not None:
+                        dep_registration = self._registry.get_function(type(dep_config))
+                        if dep_registration.is_per_user:
+                            raise ValueError(f"Function `{fn_name}` depends on per-user function `{dep_fn_name}`")
+
+                for dep_fg_name in fn_deps.function_groups:
+                    dep_config = config.function_groups.get(dep_fg_name)
+                    if dep_config is not None:
+                        dep_registration = self._registry.get_function_group(type(dep_config))
+                        if dep_registration.is_per_user:
+                            raise ValueError(f"Function `{fn_name}` depends on per-user function_group `{dep_fg_name}`")
+
+        # Check shared function_groups do not depend on per-user functions or function_groups
+        for fg_name, fg_deps in self.function_group_dependencies.items():
+            fg_config = self.get_function_group_config(fg_name)
+            fg_registration = self._registry.get_function_group(type(fg_config))
+
+            if not fg_registration.is_per_user:
+                for dep_fn_name in fg_deps.functions:
+                    dep_config = config.functions.get(dep_fn_name)
+                    if dep_config is not None:
+                        dep_registration = self._registry.get_function(type(dep_config))
+                        if dep_registration.is_per_user:
+                            raise ValueError(f"FunctionGroup `{fg_name}` depends on per-user function `{dep_fn_name}`")
+
+                for dep_fg_name in fg_deps.function_groups:
+                    dep_config = config.function_groups.get(dep_fg_name)
+                    if dep_config is not None:
+                        dep_registration = self._registry.get_function_group(type(dep_config))
+                        if dep_registration.is_per_user:
+                            raise ValueError(
+                                f"FunctionGroup `{fg_name}` depends on per-user function_group `{dep_fg_name}`")
 
-    @override
-    async def get_ttc_strategy(self,
-                               strategy_name: str | TTCStrategyRef,
-                               pipeline_type: PipelineTypeEnum,
-                               stage_type: StageTypeEnum) -> StrategyBase:
-        return await self._workflow_builder.get_ttc_strategy(strategy_name=strategy_name,
-                                                             pipeline_type=pipeline_type,
-                                                             stage_type=stage_type)
-
-    @override
-    async def get_ttc_strategy_config(self,
-                                      strategy_name: str | TTCStrategyRef,
-                                      pipeline_type: PipelineTypeEnum,
-                                      stage_type: StageTypeEnum) -> TTCStrategyBaseConfig:
-        return await self._workflow_builder.get_ttc_strategy_config(strategy_name=strategy_name,
-                                                                    pipeline_type=pipeline_type,
-                                                                    stage_type=stage_type)
-
-    @override
-    async def add_retriever(self, name: str, config: RetrieverBaseConfig) -> None:
-        await self._workflow_builder.add_retriever(name, config)
-
-    @override
-    async def get_retriever(self, retriever_name: str, wrapper_type: LLMFrameworkEnum | str | None = None) -> Retriever:
-        if not wrapper_type:
-            return await self._workflow_builder.get_retriever(retriever_name=retriever_name)
-        return await self._workflow_builder.get_retriever(retriever_name=retriever_name, wrapper_type=wrapper_type)
+        if self._workflow is not None:
+            workflow_config = self.get_workflow_config()
+            workflow_registration = self._registry.get_function(type(workflow_config))
 
-    @override
-    async def get_retriever_config(self, retriever_name: str) -> RetrieverBaseConfig:
-        return await self._workflow_builder.get_retriever_config(retriever_name=retriever_name)
+            # Per-user workflow must be owned by PerUserWorkflowBuilder
+            if workflow_registration.is_per_user:
+                raise ValueError("Workflow is a per-user function, but it is owned by a shared WorkflowBuilder")
 
-    @override
-    def get_user_manager(self) -> UserManagerHolder:
-        return self._workflow_builder.get_user_manager()
+            else:
+                workflow_deps = self.function_dependencies.get(WORKFLOW_COMPONENT_NAME, FunctionDependencies())
+
+                for dep_fn_name in workflow_deps.functions:
+                    if dep_fn_name in config.functions:
+                        dep_config = config.functions[dep_fn_name]
+                        if dep_config is not None:
+                            dep_registration = self._registry.get_function(type(dep_config))
+                            if dep_registration.is_per_user:
+                                raise ValueError(f"Shared Workflow depends on per-user function `{dep_fn_name}`")
+
+                for dep_fg_name in workflow_deps.function_groups:
+                    if dep_fg_name in config.function_groups:
+                        dep_config = config.function_groups[dep_fg_name]
+                        if dep_config is not None:
+                            dep_registration = self._registry.get_function_group(type(dep_config))
+                            if dep_registration.is_per_user:
+                                raise ValueError(f"Shared Workflow depends on per-user function_group `{dep_fg_name}`")
 
-    @override
-    def get_function_dependencies(self, fn_name: str) -> FunctionDependencies:
-        return self._workflow_builder.get_function_dependencies(fn_name)
+    @classmethod
+    @asynccontextmanager
+    async def from_config(cls, config: Config):
 
-    @override
-    def get_function_group_dependencies(self, fn_name: str) -> FunctionDependencies:
-        return self._workflow_builder.get_function_group_dependencies(fn_name)
+        async with cls(general_config=config.general) as builder:
+            await builder.populate_builder(config)
+            yield builder