add basic integration test

llama_stack/distribution/credentials.py

@@ -106,10 +106,10 @@ class DistributionCredentialsImpl(CredentialsAPI, CredentialsStore):
         principal = get_principal()
 
         # check that provider_id is registered
-        run_config = self.deps[Api.inspect].run_config
+        run_config = self.deps[Api.inspect].config.run_config
 
         # TODO: we should make provider_ids unique across all APIs which is not enforced yet
-        provider_ids = [p.provider_id for p in run_config.providers.values()]
+        provider_ids = [p.provider_id for plist in run_config.providers.values() for p in plist]
         if provider_id not in provider_ids:
             raise ValueError(f"Provider {provider_id} is not registered")
 

llama_stack/distribution/resolver.py

@@ -9,6 +9,7 @@ from typing import Any
 
 from llama_stack.apis.agents import Agents
 from llama_stack.apis.benchmarks import Benchmarks
+from llama_stack.apis.credentials import Credentials
 from llama_stack.apis.datasetio import DatasetIO
 from llama_stack.apis.datasets import Datasets
 from llama_stack.apis.eval import Eval
@@ -61,6 +62,7 @@ class InvalidProviderError(Exception):
 def api_protocol_map() -> dict[Api, Any]:
     return {
         Api.providers: ProvidersAPI,
+        Api.credentials: Credentials,
         Api.agents: Agents,
         Api.inference: Inference,
         Api.inspect: Inspect,

llama_stack/distribution/stack.py

@@ -41,9 +41,11 @@ from llama_stack.distribution.inspect import DistributionInspectConfig, Distribu
 from llama_stack.distribution.providers import ProviderImpl, ProviderImplConfig
 from llama_stack.distribution.resolver import ProviderRegistry, resolve_impls
 from llama_stack.distribution.store.registry import create_dist_registry
+from llama_stack.distribution.utils.config_dirs import DISTRIBS_BASE_DIR
 from llama_stack.distribution.utils.dynamic import instantiate_class_type
 from llama_stack.log import get_logger
 from llama_stack.providers.datatypes import Api
+from llama_stack.providers.utils.kvstore.config import SqliteKVStoreConfig
 
 logger = get_logger(name=__name__, category="core")
 
@@ -214,8 +216,12 @@ async def instantiate_internal_impls(impls: dict[Api, Any], run_config: StackRun
     )
     await providers_impl.initialize()
 
+    # TODO: make metadata_store and credentials_store non-optional by including it in the templates
     credentials_impl = DistributionCredentialsImpl(
-        DistributionCredentialsConfig(kvstore=run_config.credentials_store),
+        DistributionCredentialsConfig(
+            kvstore=run_config.credentials_store
+            or SqliteKVStoreConfig(db_path=(DISTRIBS_BASE_DIR / run_config.image_name / "credentials.db").as_posix())
+        ),
         deps=impls,
     )
     await credentials_impl.initialize()
@@ -231,18 +237,26 @@ async def instantiate_internal_impls(impls: dict[Api, Any], run_config: StackRun
 async def construct_stack(
     run_config: StackRunConfig, provider_registry: ProviderRegistry | None = None
 ) -> dict[Api, Any]:
-    dist_registry, _ = await create_dist_registry(run_config.metadata_store, run_config.image_name)
+    kvstore_config = run_config.metadata_store or SqliteKVStoreConfig(
+        db_path=(DISTRIBS_BASE_DIR / run_config.image_name / "kvstore.db").as_posix()
+    )
+    dist_registry, _ = await create_dist_registry(kvstore_config)
     impls = await resolve_impls(run_config, provider_registry or get_provider_registry(run_config), dist_registry)
 
     # Add internal implementations after all other providers are resolved
     internal_impls = await instantiate_internal_impls(impls, run_config)
     impls.update(internal_impls)
 
-    # credentials_store = internal_impls[Api.credentials]
-    # for impl in impls.values():
-    #     # in an ideal world, we would pass the credentials store as a dependency
-    #     if hasattr(impl, "credentials_store"):
-    #         impl.credentials_store = credentials_store
+    # HACK: this is a hack to work around circular dependency issues. we probably need to
+    # make resolving internal implementations be part of `resolve_impls` again (as it used to be
+    # a while ago) so that dependencies can be expressed properly.
+    for impl in impls.values():
+        from llama_stack.distribution.routers.routing_tables import CommonRoutingTableImpl
+
+        if isinstance(impl, CommonRoutingTableImpl):
+            for provider_impl in impl.impls_by_provider_id.values():
+                if hasattr(provider_impl, "credentials_store"):
+                    provider_impl.credentials_store = internal_impls[Api.credentials]
 
     await register_resources(run_config, impls)
     return impls

llama_stack/distribution/store/registry.py

@@ -11,10 +11,8 @@ from typing import Protocol
 import pydantic
 
 from llama_stack.distribution.datatypes import KVStoreConfig, RoutableObjectWithProvider
-from llama_stack.distribution.utils.config_dirs import DISTRIBS_BASE_DIR
 from llama_stack.log import get_logger
 from llama_stack.providers.utils.kvstore import KVStore, kvstore_impl
-from llama_stack.providers.utils.kvstore.config import SqliteKVStoreConfig
 
 logger = get_logger(__name__, category="core")
 
@@ -189,16 +187,9 @@ class CachedDiskDistributionRegistry(DiskDistributionRegistry):
 
 
 async def create_dist_registry(
-    metadata_store: KVStoreConfig | None,
-    image_name: str,
+    kvstore_config: KVStoreConfig,
 ) -> tuple[CachedDiskDistributionRegistry, KVStore]:
-    # instantiate kvstore for storing and retrieving distribution metadata
-    if metadata_store:
-        dist_kvstore = await kvstore_impl(metadata_store)
-    else:
-        dist_kvstore = await kvstore_impl(
-            SqliteKVStoreConfig(db_path=(DISTRIBS_BASE_DIR / image_name / "kvstore.db").as_posix())
-        )
+    dist_kvstore = await kvstore_impl(kvstore_config)
     dist_registry = CachedDiskDistributionRegistry(dist_kvstore)
     await dist_registry.initialize()
     return dist_registry, dist_kvstore