Introduce a "Router" layer for providers

Some providers need to be factorized and considered as thin routing
layers on top of other providers. Consider two examples:

- The inference API should be a routing layer over inference providers,
  routed using the "model" key
- The memory banks API is another instance where various memory bank
  types will be provided by independent providers (e.g., a vector store
  is served by Chroma while a keyvalue memory can be served by Redis or
  PGVector)

This commit introduces a generalized routing layer for this purpose.

llama_toolchain/core/dynamic.py

@@ -4,11 +4,10 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
-import asyncio
 import importlib
 from typing import Any, Dict
 
-from .datatypes import ProviderSpec, RemoteProviderSpec
+from llama_toolchain.core.datatypes import *  # noqa: F403
 
 
 def instantiate_class_type(fully_qualified_name):
@@ -18,25 +17,50 @@ def instantiate_class_type(fully_qualified_name):
 
 
 # returns a class implementing the protocol corresponding to the Api
-def instantiate_provider(
+async def instantiate_provider(
     provider_spec: ProviderSpec,
-    provider_config: Dict[str, Any],
-    deps: Dict[str, ProviderSpec],
+    deps: Dict[str, Any],
+    provider_config: ProviderMapEntry,
 ):
     module = importlib.import_module(provider_spec.module)
 
-    config_type = instantiate_class_type(provider_spec.config_class)
+    args = []
     if isinstance(provider_spec, RemoteProviderSpec):
         if provider_spec.adapter:
             method = "get_adapter_impl"
         else:
             method = "get_client_impl"
+
+        assert isinstance(provider_config, GenericProviderConfig)
+        config_type = instantiate_class_type(provider_spec.config_class)
+        config = config_type(**provider_config.config)
+        args = [config, deps]
+    elif isinstance(provider_spec, RouterProviderSpec):
+        method = "get_router_impl"
+
+        assert isinstance(provider_config, list)
+        inner_specs = {x.provider_id: x for x in provider_spec.inner_specs}
+        inner_impls = []
+        for routing_entry in provider_config:
+            impl = await instantiate_provider(
+                inner_specs[routing_entry.provider_id],
+                deps,
+                routing_entry,
+            )
+            inner_impls.append((routing_entry.routing_key, impl))
+
+        config = None
+        args = [inner_impls, deps]
     else:
         method = "get_provider_impl"
 
-    config = config_type(**provider_config)
+        assert isinstance(provider_config, GenericProviderConfig)
+        config_type = instantiate_class_type(provider_spec.config_class)
+        config = config_type(**provider_config.config)
+        args = [config, deps]
+
     fn = getattr(module, method)
-    impl = asyncio.run(fn(config, deps))
+    impl = await fn(*args)
     impl.__provider_spec__ = provider_spec
     impl.__provider_config__ = config
     return impl