feat: remove usage of build yaml (#4192)

# What does this PR do?

the build.yaml is only used in the following ways:

1. list-deps
2. distribution code-gen

since `llama stack build` no longer exists, I found myself asking "why
do we need two different files for list-deps and run"?

Removing the BuildConfig and altering the usage of the
DistributionTemplate in llama stack list-deps is the first step in
removing the build yaml entirely.

Removing the BuildConfig and build.yaml cuts the files users need to
maintain in half, and allows us to focus on the stability of _just_ the
run.yaml

This PR removes the build.yaml, BuildConfig datatype, and its usage
throughout the codebase. Users are now expected to point to run.yaml
files when running list-deps, and our codebase automatically uses these
types now for things like `get_provider_registry`.

**Additionally, two renames: `StackRunConfig` -> `StackConfig` and
`run.yaml` -> `config.yaml`.**

The build.yaml made sense for when we were managing the build process
for the user and actually _producing_ a run.yaml _from_ the build.yaml,
but now that we are simply just getting the provider registry and
listing the deps, switching to config.yaml simplifies the scope here
greatly.

## Test Plan

existing list-deps usage should work in the tests.

---------

Signed-off-by: Charlie Doern <cdoern@redhat.com>

src/llama_stack/cli/stack/_list_deps.py

@@ -11,15 +11,9 @@ from pathlib import Path
 import yaml
 from termcolor import cprint
 
-from llama_stack.cli.stack.utils import ImageType
 from llama_stack.core.build import get_provider_dependencies
-from llama_stack.core.datatypes import (
-    BuildConfig,
-    BuildProvider,
-    DistributionSpec,
-)
+from llama_stack.core.datatypes import Provider, StackConfig
 from llama_stack.core.distribution import get_provider_registry
-from llama_stack.core.stack import replace_env_vars
 from llama_stack.log import get_logger
 from llama_stack_api import Api
 
@@ -70,9 +64,9 @@ def format_output_deps_only(
 def run_stack_list_deps_command(args: argparse.Namespace) -> None:
     if args.config:
         try:
-            from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_distro
+            from llama_stack.core.utils.config_resolution import resolve_config_or_distro
 
-            config_file = resolve_config_or_distro(args.config, Mode.BUILD)
+            config_file = resolve_config_or_distro(args.config)
         except ValueError as e:
             cprint(
                 f"Could not parse config file {args.config}: {e}",
@@ -84,9 +78,7 @@ def run_stack_list_deps_command(args: argparse.Namespace) -> None:
             with open(config_file) as f:
                 try:
                     contents = yaml.safe_load(f)
-                    contents = replace_env_vars(contents)
-                    build_config = BuildConfig(**contents)
-                    build_config.image_type = "venv"
+                    config = StackConfig(**contents)
                 except Exception as e:
                     cprint(
                         f"Could not parse config file {config_file}: {e}",
@@ -95,7 +87,7 @@ def run_stack_list_deps_command(args: argparse.Namespace) -> None:
                     )
                     sys.exit(1)
     elif args.providers:
-        provider_list: dict[str, list[BuildProvider]] = dict()
+        provider_list: dict[str, list[Provider]] = dict()
         for api_provider in args.providers.split(","):
             if "=" not in api_provider:
                 cprint(
@@ -114,8 +106,9 @@ def run_stack_list_deps_command(args: argparse.Namespace) -> None:
                 )
                 sys.exit(1)
             if provider_type in providers_for_api:
-                provider = BuildProvider(
+                provider = Provider(
                     provider_type=provider_type,
+                    provider_id=provider_type.split("::")[1],
                     module=None,
                 )
                 provider_list.setdefault(api, []).append(provider)
@@ -126,20 +119,16 @@ def run_stack_list_deps_command(args: argparse.Namespace) -> None:
                     file=sys.stderr,
                 )
                 sys.exit(1)
-        distribution_spec = DistributionSpec(
-            providers=provider_list,
-            description=",".join(args.providers),
-        )
-        build_config = BuildConfig(image_type=ImageType.VENV.value, distribution_spec=distribution_spec)
+        config = StackConfig(providers=provider_list, image_name="providers-run")
 
-    normal_deps, special_deps, external_provider_dependencies = get_provider_dependencies(build_config)
+    normal_deps, special_deps, external_provider_dependencies = get_provider_dependencies(config)
     normal_deps += SERVER_DEPENDENCIES
 
     # Add external API dependencies
-    if build_config.external_apis_dir:
+    if config.external_apis_dir:
         from llama_stack.core.external import load_external_apis
 
-        external_apis = load_external_apis(build_config)
+        external_apis = load_external_apis(config)
         if external_apis:
             for _, api_spec in external_apis.items():
                 normal_deps.extend(api_spec.pip_packages)

src/llama_stack/cli/stack/list_stacks.py

@@ -59,19 +59,17 @@ class StackListBuilds(Subcommand):
             print("No distributions found")
             return
 
-        headers = ["Stack Name", "Source", "Path", "Build Config", "Run Config"]
+        headers = ["Stack Name", "Source", "Path", "Config"]
         rows = []
         for name, (path, source_type) in sorted(distributions.items()):
             row = [name, source_type, str(path)]
-            # Check for build and run config files
-            # For built-in distributions, configs are named build.yaml and run.yaml
-            # For custom distributions, configs are named {name}-build.yaml and {name}-run.yaml
+            # Check for config files
+            # For built-in distributions, configs are named config.yaml
+            # For custom distributions, configs are named {name}-config.yaml
             if source_type == "built-in":
-                build_config = "Yes" if (path / "build.yaml").exists() else "No"
-                run_config = "Yes" if (path / "run.yaml").exists() else "No"
+                config = "Yes" if (path / "config.yaml").exists() else "No"
             else:
-                build_config = "Yes" if (path / f"{name}-build.yaml").exists() else "No"
-                run_config = "Yes" if (path / f"{name}-run.yaml").exists() else "No"
-            row.extend([build_config, run_config])
+                config = "Yes" if (path / f"{name}-config.yaml").exists() else "No"
+            row.extend([config])
             rows.append(row)
         print_table(rows, headers, separate_rows=True)

src/llama_stack/cli/stack/run.py

@@ -17,7 +17,7 @@ from termcolor import cprint
 
 from llama_stack.cli.stack.utils import ImageType
 from llama_stack.cli.subcommand import Subcommand
-from llama_stack.core.datatypes import Api, Provider, StackRunConfig
+from llama_stack.core.datatypes import Api, Provider, StackConfig
 from llama_stack.core.distribution import get_provider_registry
 from llama_stack.core.stack import cast_image_name_to_string, replace_env_vars
 from llama_stack.core.storage.datatypes import (
@@ -30,7 +30,7 @@ from llama_stack.core.storage.datatypes import (
     StorageConfig,
 )
 from llama_stack.core.utils.config_dirs import DISTRIBS_BASE_DIR
-from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_distro
+from llama_stack.core.utils.config_resolution import resolve_config_or_distro
 from llama_stack.core.utils.dynamic import instantiate_class_type
 from llama_stack.log import LoggingConfig, get_logger
 
@@ -108,9 +108,9 @@ class StackRun(Subcommand):
 
         if args.config:
             try:
-                from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_distro
+                from llama_stack.core.utils.config_resolution import resolve_config_or_distro
 
-                config_file = resolve_config_or_distro(args.config, Mode.RUN)
+                config_file = resolve_config_or_distro(args.config)
             except ValueError as e:
                 self.parser.error(str(e))
         elif args.providers:
@@ -156,7 +156,7 @@ class StackRun(Subcommand):
 
             # Write config to disk in providers-run directory
             distro_dir = DISTRIBS_BASE_DIR / "providers-run"
-            config_file = distro_dir / "run.yaml"
+            config_file = distro_dir / "config.yaml"
 
             logger.info(f"Writing generated config to: {config_file}")
             with open(config_file, "w") as f:
@@ -187,14 +187,14 @@ class StackRun(Subcommand):
         if not config_file:
             self.parser.error("Config file is required")
 
-        config_file = resolve_config_or_distro(str(config_file), Mode.RUN)
+        config_file = resolve_config_or_distro(str(config_file))
         with open(config_file) as fp:
             config_contents = yaml.safe_load(fp)
             if isinstance(config_contents, dict) and (cfg := config_contents.get("logging_config")):
                 logger_config = LoggingConfig(**cfg)
             else:
                 logger_config = None
-            config = StackRunConfig(**cast_image_name_to_string(replace_env_vars(config_contents)))
+            config = StackConfig(**cast_image_name_to_string(replace_env_vars(config_contents)))
 
         port = args.port or config.server.port
         host = config.server.host or ["::", "0.0.0.0"]
@@ -318,7 +318,7 @@ class StackRun(Subcommand):
             ),
         )
 
-        return StackRunConfig(
+        return StackConfig(
             image_name="providers-run",
             apis=apis,
             providers=providers,

src/llama_stack/cli/stack/utils.py

@@ -4,36 +4,9 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
-import json
-import sys
 from enum import Enum
-from functools import lru_cache
 from pathlib import Path
 
-import yaml
-from termcolor import cprint
-
-from llama_stack.core.datatypes import (
-    BuildConfig,
-    Provider,
-    StackRunConfig,
-    StorageConfig,
-)
-from llama_stack.core.distribution import get_provider_registry
-from llama_stack.core.resolver import InvalidProviderError
-from llama_stack.core.storage.datatypes import (
-    InferenceStoreReference,
-    KVStoreReference,
-    ServerStoresConfig,
-    SqliteKVStoreConfig,
-    SqliteSqlStoreConfig,
-    SqlStoreReference,
-)
-from llama_stack.core.utils.config_dirs import DISTRIBS_BASE_DIR, EXTERNAL_PROVIDERS_DIR
-from llama_stack.core.utils.dynamic import instantiate_class_type
-from llama_stack.core.utils.image_types import LlamaStackImageType
-from llama_stack_api import Api
-
 TEMPLATES_PATH = Path(__file__).parent.parent.parent / "distributions"
 
 
@@ -49,103 +22,3 @@ def print_subcommand_description(parser, subparsers):
         description = subcommand.description
         description_text += f"  {name:<21} {description}\n"
     parser.epilog = description_text
-
-
-def generate_run_config(
-    build_config: BuildConfig,
-    build_dir: Path,
-    image_name: str,
-) -> Path:
-    """
-    Generate a run.yaml template file for user to edit from a build.yaml file
-    """
-    apis = list(build_config.distribution_spec.providers.keys())
-    distro_dir = DISTRIBS_BASE_DIR / image_name
-    run_config = StackRunConfig(
-        container_image=(image_name if build_config.image_type == LlamaStackImageType.CONTAINER.value else None),
-        image_name=image_name,
-        apis=apis,
-        providers={},
-        storage=StorageConfig(
-            backends={
-                "kv_default": SqliteKVStoreConfig(db_path=str(distro_dir / "kvstore.db")),
-                "sql_default": SqliteSqlStoreConfig(db_path=str(distro_dir / "sql_store.db")),
-            },
-            stores=ServerStoresConfig(
-                metadata=KVStoreReference(backend="kv_default", namespace="registry"),
-                inference=InferenceStoreReference(backend="sql_default", table_name="inference_store"),
-                conversations=SqlStoreReference(backend="sql_default", table_name="openai_conversations"),
-            ),
-        ),
-        external_providers_dir=build_config.external_providers_dir
-        if build_config.external_providers_dir
-        else EXTERNAL_PROVIDERS_DIR,
-    )
-    # build providers dict
-    provider_registry = get_provider_registry(build_config)
-    for api in apis:
-        run_config.providers[api] = []
-        providers = build_config.distribution_spec.providers[api]
-
-        for provider in providers:
-            pid = provider.provider_type.split("::")[-1]
-
-            p = provider_registry[Api(api)][provider.provider_type]
-            if p.deprecation_error:
-                raise InvalidProviderError(p.deprecation_error)
-
-            try:
-                config_type = instantiate_class_type(provider_registry[Api(api)][provider.provider_type].config_class)
-            except (ModuleNotFoundError, ValueError) as exc:
-                # HACK ALERT:
-                # This code executes after building is done, the import cannot work since the
-                # package is either available in the venv or container - not available on the host.
-                # TODO: use a "is_external" flag in ProviderSpec to check if the provider is
-                # external
-                cprint(
-                    f"Failed to import provider {provider.provider_type} for API {api} - assuming it's external, skipping: {exc}",
-                    color="yellow",
-                    file=sys.stderr,
-                )
-                # Set config_type to None to avoid UnboundLocalError
-                config_type = None
-
-            if config_type is not None and hasattr(config_type, "sample_run_config"):
-                config = config_type.sample_run_config(__distro_dir__=f"~/.llama/distributions/{image_name}")
-            else:
-                config = {}
-
-            p_spec = Provider(
-                provider_id=pid,
-                provider_type=provider.provider_type,
-                config=config,
-                module=provider.module,
-            )
-            run_config.providers[api].append(p_spec)
-
-    run_config_file = build_dir / f"{image_name}-run.yaml"
-
-    with open(run_config_file, "w") as f:
-        to_write = json.loads(run_config.model_dump_json())
-        f.write(yaml.dump(to_write, sort_keys=False))
-
-    # Only print this message for non-container builds since it will be displayed before the
-    # container is built
-    # For non-container builds, the run.yaml is generated at the very end of the build process so it
-    # makes sense to display this message
-    if build_config.image_type != LlamaStackImageType.CONTAINER.value:
-        cprint(f"You can now run your stack with `llama stack run {run_config_file}`", color="green", file=sys.stderr)
-    return run_config_file
-
-
-@lru_cache
-def available_templates_specs() -> dict[str, BuildConfig]:
-    import yaml
-
-    template_specs = {}
-    for p in TEMPLATES_PATH.rglob("*build.yaml"):
-        template_name = p.parent.name
-        with open(p) as f:
-            build_config = BuildConfig(**yaml.safe_load(f))
-            template_specs[template_name] = build_config
-    return template_specs

src/llama_stack/core/build.py

@@ -9,7 +9,7 @@ import sys
 from pydantic import BaseModel
 from termcolor import cprint
 
-from llama_stack.core.datatypes import BuildConfig
+from llama_stack.core.datatypes import StackConfig
 from llama_stack.core.distribution import get_provider_registry
 from llama_stack.distributions.template import DistributionTemplate
 from llama_stack.log import get_logger
@@ -36,18 +36,17 @@ class ApiInput(BaseModel):
 
 
 def get_provider_dependencies(
-    config: BuildConfig | DistributionTemplate,
+    config: StackConfig,
 ) -> tuple[list[str], list[str], list[str]]:
     """Get normal and special dependencies from provider configuration."""
     if isinstance(config, DistributionTemplate):
         config = config.build_config()
 
-    providers = config.distribution_spec.providers
-    additional_pip_packages = config.additional_pip_packages
+    providers = config.providers
 
     deps = []
     external_provider_deps = []
-    registry = get_provider_registry(config)
+    registry = get_provider_registry(config=config, listing=True)
     for api_str, provider_or_providers in providers.items():
         providers_for_api = registry[Api(api_str)]
 
@@ -81,12 +80,10 @@ def get_provider_dependencies(
         else:
             normal_deps.append(package)
 
-    normal_deps.extend(additional_pip_packages or [])
-
     return list(set(normal_deps)), list(set(special_deps)), list(set(external_provider_deps))
 
 
-def print_pip_install_help(config: BuildConfig):
+def print_pip_install_help(config: StackConfig):
     normal_deps, special_deps, _ = get_provider_dependencies(config)
 
     cprint(

src/llama_stack/core/configure.py

@@ -10,7 +10,7 @@ from llama_stack.core.datatypes import (
     LLAMA_STACK_RUN_CONFIG_VERSION,
     DistributionSpec,
     Provider,
-    StackRunConfig,
+    StackConfig,
 )
 from llama_stack.core.distribution import (
     builtin_automatically_routed_apis,
@@ -44,7 +44,7 @@ def configure_single_provider(registry: dict[str, ProviderSpec], provider: Provi
     )
 
 
-def configure_api_providers(config: StackRunConfig, build_spec: DistributionSpec) -> StackRunConfig:
+def configure_api_providers(config: StackConfig, build_spec: DistributionSpec) -> StackConfig:
     is_nux = len(config.providers) == 0
 
     if is_nux:
@@ -192,7 +192,7 @@ def upgrade_from_routing_table(
     return config_dict
 
 
-def parse_and_maybe_upgrade_config(config_dict: dict[str, Any]) -> StackRunConfig:
+def parse_and_maybe_upgrade_config(config_dict: dict[str, Any]) -> StackConfig:
     if "routing_table" in config_dict:
         logger.info("Upgrading config...")
         config_dict = upgrade_from_routing_table(config_dict)
@@ -200,4 +200,4 @@ def parse_and_maybe_upgrade_config(config_dict: dict[str, Any]) -> StackRunConfi
     config_dict["version"] = LLAMA_STACK_RUN_CONFIG_VERSION
 
     processed_config_dict = replace_env_vars(config_dict)
-    return StackRunConfig(**cast_image_name_to_string(processed_config_dict))
+    return StackConfig(**cast_image_name_to_string(processed_config_dict))

src/llama_stack/core/conversations/conversations.py

@@ -10,7 +10,7 @@ from typing import Any, Literal
 
 from pydantic import BaseModel, TypeAdapter
 
-from llama_stack.core.datatypes import AccessRule, StackRunConfig
+from llama_stack.core.datatypes import AccessRule, StackConfig
 from llama_stack.core.storage.sqlstore.authorized_sqlstore import AuthorizedSqlStore
 from llama_stack.core.storage.sqlstore.sqlstore import sqlstore_impl
 from llama_stack.log import get_logger
@@ -36,7 +36,7 @@ class ConversationServiceConfig(BaseModel):
     :param policy: Access control rules
     """
 
-    run_config: StackRunConfig
+    config: StackConfig
     policy: list[AccessRule] = []
 
 
@@ -56,7 +56,7 @@ class ConversationServiceImpl(Conversations):
         self.policy = config.policy
 
         # Use conversations store reference from run config
-        conversations_ref = config.run_config.storage.stores.conversations
+        conversations_ref = config.config.storage.stores.conversations
         if not conversations_ref:
             raise ValueError("storage.stores.conversations must be configured in run config")
 

src/llama_stack/core/datatypes.py

@@ -474,7 +474,7 @@ class ServerConfig(BaseModel):
     )
 
 
-class StackRunConfig(BaseModel):
+class StackConfig(BaseModel):
     version: int = LLAMA_STACK_RUN_CONFIG_VERSION
 
     image_name: str = Field(
@@ -501,6 +501,7 @@ can be instantiated multiple times (with different configs) if necessary.
 """,
     )
     storage: StorageConfig = Field(
+        default_factory=StorageConfig,
         description="Catalog of named storage backends and references available to the stack",
     )
 
@@ -546,7 +547,7 @@ can be instantiated multiple times (with different configs) if necessary.
         return v
 
     @model_validator(mode="after")
-    def validate_server_stores(self) -> "StackRunConfig":
+    def validate_server_stores(self) -> "StackConfig":
         backend_map = self.storage.backends
         stores = self.storage.stores
         kv_backends = {
@@ -588,39 +589,3 @@ can be instantiated multiple times (with different configs) if necessary.
         _ensure_backend(stores.responses, sql_backends, "storage.stores.responses")
         _ensure_backend(stores.prompts, kv_backends, "storage.stores.prompts")
         return self
-
-
-class BuildConfig(BaseModel):
-    version: int = LLAMA_STACK_BUILD_CONFIG_VERSION
-
-    distribution_spec: DistributionSpec = Field(description="The distribution spec to build including API providers. ")
-    image_type: str = Field(
-        default="venv",
-        description="Type of package to build (container | venv)",
-    )
-    image_name: str | None = Field(
-        default=None,
-        description="Name of the distribution to build",
-    )
-    external_providers_dir: Path | None = Field(
-        default=None,
-        description="Path to directory containing external provider implementations. The providers packages will be resolved from this directory. "
-        "pip_packages MUST contain the provider package name.",
-    )
-    additional_pip_packages: list[str] = Field(
-        default_factory=list,
-        description="Additional pip packages to install in the distribution. These packages will be installed in the distribution environment.",
-    )
-    external_apis_dir: Path | None = Field(
-        default=None,
-        description="Path to directory containing external API implementations. The APIs code and dependencies must be installed on the system.",
-    )
-
-    @field_validator("external_providers_dir")
-    @classmethod
-    def validate_external_providers_dir(cls, v):
-        if v is None:
-            return None
-        if isinstance(v, str):
-            return Path(v)
-        return v

src/llama_stack/core/distribution.py

@@ -12,7 +12,7 @@ from typing import Any
 import yaml
 from pydantic import BaseModel
 
-from llama_stack.core.datatypes import BuildConfig, DistributionSpec
+from llama_stack.core.datatypes import StackConfig
 from llama_stack.core.external import load_external_apis
 from llama_stack.log import get_logger
 from llama_stack_api import (
@@ -85,7 +85,9 @@ def _load_inline_provider_spec(spec_data: dict[str, Any], api: Api, provider_nam
     return spec
 
 
-def get_provider_registry(config=None) -> dict[Api, dict[str, ProviderSpec]]:
+def get_provider_registry(
+    config: StackConfig | None = None, listing: bool = False
+) -> dict[Api, dict[str, ProviderSpec]]:
     """Get the provider registry, optionally including external providers.
 
     This function loads both built-in providers and external providers from YAML files or from their provided modules.
@@ -109,13 +111,13 @@ def get_provider_registry(config=None) -> dict[Api, dict[str, ProviderSpec]]:
         safety/
           llama-guard.yaml
 
-    This method is overloaded in that it can be called from a variety of places: during build, during run, during stack construction.
-    So when building external providers from a module, there are scenarios where the pip package required to import the module might not be available yet.
+    This method is overloaded in that it can be called from a variety of places: during list-deps, during run, during stack construction.
+    So when listing external providers from a module, there are scenarios where the pip package required to import the module might not be available yet.
     There is special handling for all of the potential cases this method can be called from.
 
     Args:
         config: Optional object containing the external providers directory path
-        building: Optional bool delineating whether or not this is being called from a build process
+        listing: Optional bool delineating whether or not this is being called from a list-deps process
 
     Returns:
         A dictionary mapping APIs to their available providers
@@ -161,7 +163,7 @@ def get_provider_registry(config=None) -> dict[Api, dict[str, ProviderSpec]]:
         registry = get_external_providers_from_module(
             registry=registry,
             config=config,
-            building=(isinstance(config, BuildConfig) or isinstance(config, DistributionSpec)),
+            listing=listing,
         )
 
     return registry
@@ -220,13 +222,10 @@ def get_external_providers_from_dir(
 
 
 def get_external_providers_from_module(
-    registry: dict[Api, dict[str, ProviderSpec]], config, building: bool
+    registry: dict[Api, dict[str, ProviderSpec]], config, listing: bool
 ) -> dict[Api, dict[str, ProviderSpec]]:
     provider_list = None
-    if isinstance(config, BuildConfig):
-        provider_list = config.distribution_spec.providers.items()
-    else:
-        provider_list = config.providers.items()
+    provider_list = config.providers.items()
     if provider_list is None:
         logger.warning("Could not get list of providers from config")
         return registry
@@ -236,14 +235,14 @@ def get_external_providers_from_module(
                 continue
             # get provider using module
             try:
-                if not building:
+                if not listing:
                     package_name = provider.module.split("==")[0]
                     module = importlib.import_module(f"{package_name}.provider")
                     # if config class is wrong you will get an error saying module could not be imported
                     spec = module.get_provider_spec()
                 else:
-                    # pass in a partially filled out provider spec to satisfy the registry -- knowing we will be overwriting it later upon build and run
-                    # in the case we are building we CANNOT import this module of course because it has not been installed.
+                    # pass in a partially filled out provider spec to satisfy the registry -- knowing we will be overwriting it later upon list-deps and run
+                    # in the case we are listing we CANNOT import this module of course because it has not been installed.
                     spec = ProviderSpec(
                         api=Api(provider_api),
                         provider_type=provider.provider_type,

src/llama_stack/core/external.py

@@ -7,14 +7,14 @@
 
 import yaml
 
-from llama_stack.core.datatypes import BuildConfig, StackRunConfig
+from llama_stack.core.datatypes import StackConfig
 from llama_stack.log import get_logger
 from llama_stack_api import Api, ExternalApiSpec
 
 logger = get_logger(name=__name__, category="core")
 
 
-def load_external_apis(config: StackRunConfig | BuildConfig | None) -> dict[Api, ExternalApiSpec]:
+def load_external_apis(config: StackConfig | None) -> dict[Api, ExternalApiSpec]:
     """Load external API specifications from the configured directory.
 
     Args:

src/llama_stack/core/inspect.py

@@ -8,7 +8,7 @@ from importlib.metadata import version
 
 from pydantic import BaseModel
 
-from llama_stack.core.datatypes import StackRunConfig
+from llama_stack.core.datatypes import StackConfig
 from llama_stack.core.external import load_external_apis
 from llama_stack.core.server.fastapi_router_registry import (
     _ROUTER_FACTORIES,
@@ -28,7 +28,7 @@ from llama_stack_api import (
 
 
 class DistributionInspectConfig(BaseModel):
-    run_config: StackRunConfig
+    config: StackConfig
 
 
 async def get_provider_impl(config, deps):
@@ -39,14 +39,14 @@ async def get_provider_impl(config, deps):
 
 class DistributionInspectImpl(Inspect):
     def __init__(self, config: DistributionInspectConfig, deps):
-        self.config = config
+        self.stack_config = config.config
         self.deps = deps
 
     async def initialize(self) -> None:
         pass
 
     async def list_routes(self, api_filter: str | None = None) -> ListRoutesResponse:
-        run_config: StackRunConfig = self.config.run_config
+        config: StackConfig = self.stack_config
 
         # Helper function to determine if a route should be included based on api_filter
         # TODO: remove this once we've migrated all APIs to FastAPI routers
@@ -65,7 +65,7 @@ class DistributionInspectImpl(Inspect):
         def _get_provider_types(api: Api) -> list[str]:
             if api.value in ["providers", "inspect"]:
                 return []  # These APIs don't have "real" providers  they're internal to the stack
-            providers = run_config.providers.get(api.value, [])
+            providers = config.providers.get(api.value, [])
             return [p.provider_type for p in providers] if providers else []
 
         # Helper function to determine if a router route should be included based on api_filter
@@ -89,7 +89,7 @@ class DistributionInspectImpl(Inspect):
                 return not route_deprecated
 
         ret = []
-        external_apis = load_external_apis(run_config)
+        external_apis = load_external_apis(config)
         all_endpoints = get_all_api_routes(external_apis)
 
         # Process routes from APIs with FastAPI routers
@@ -131,7 +131,7 @@ class DistributionInspectImpl(Inspect):
                     ]
                 )
             else:
-                providers = run_config.providers.get(api.value, [])
+                providers = config.providers.get(api.value, [])
                 if providers:  # Only process if there are providers for this API
                     ret.extend(
                         [

src/llama_stack/core/library_client.py

@@ -41,7 +41,6 @@ from termcolor import cprint
 
 from llama_stack.core.build import print_pip_install_help
 from llama_stack.core.configure import parse_and_maybe_upgrade_config
-from llama_stack.core.datatypes import BuildConfig, BuildProvider, DistributionSpec
 from llama_stack.core.request_headers import PROVIDER_DATA_VAR, request_provider_data_context
 from llama_stack.core.resolver import ProviderRegistry
 from llama_stack.core.server.routes import RouteImpls, find_matching_route, initialize_route_impls
@@ -257,20 +256,7 @@ class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
                 file=sys.stderr,
             )
             if self.config_path_or_distro_name.endswith(".yaml"):
-                providers: dict[str, list[BuildProvider]] = {}
-                for api, run_providers in self.config.providers.items():
-                    for provider in run_providers:
-                        providers.setdefault(api, []).append(
-                            BuildProvider(provider_type=provider.provider_type, module=provider.module)
-                        )
-                providers = dict(providers)
-                build_config = BuildConfig(
-                    distribution_spec=DistributionSpec(
-                        providers=providers,
-                    ),
-                    external_providers_dir=self.config.external_providers_dir,
-                )
-                print_pip_install_help(build_config)
+                print_pip_install_help(self.config)
             else:
                 prefix = "!" if in_notebook() else ""
                 cprint(

src/llama_stack/core/prompts/prompts.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from pydantic import BaseModel
 
-from llama_stack.core.datatypes import StackRunConfig
+from llama_stack.core.datatypes import StackConfig
 from llama_stack.core.storage.kvstore import KVStore, kvstore_impl
 from llama_stack_api import ListPromptsResponse, Prompt, Prompts
 
@@ -20,7 +20,7 @@ class PromptServiceConfig(BaseModel):
     :param run_config: Stack run configuration containing distribution info
     """
 
-    run_config: StackRunConfig
+    config: StackConfig
 
 
 async def get_provider_impl(config: PromptServiceConfig, deps: dict[Any, Any]):
@@ -34,13 +34,13 @@ class PromptServiceImpl(Prompts):
     """Built-in prompt service implementation using KVStore."""
 
     def __init__(self, config: PromptServiceConfig, deps: dict[Any, Any]):
-        self.config = config
+        self.stack_config = config.config
         self.deps = deps
         self.kvstore: KVStore
 
     async def initialize(self) -> None:
         # Use prompts store reference from run config
-        prompts_ref = self.config.run_config.storage.stores.prompts
+        prompts_ref = self.stack_config.storage.stores.prompts
         if not prompts_ref:
             raise ValueError("storage.stores.prompts must be configured in run config")
         self.kvstore = await kvstore_impl(prompts_ref)

src/llama_stack/core/providers.py

@@ -12,14 +12,14 @@ from pydantic import BaseModel
 from llama_stack.log import get_logger
 from llama_stack_api import HealthResponse, HealthStatus, ListProvidersResponse, ProviderInfo, Providers
 
-from .datatypes import StackRunConfig
+from .datatypes import StackConfig
 from .utils.config import redact_sensitive_fields
 
 logger = get_logger(name=__name__, category="core")
 
 
 class ProviderImplConfig(BaseModel):
-    run_config: StackRunConfig
+    config: StackConfig
 
 
 async def get_provider_impl(config, deps):
@@ -30,7 +30,7 @@ async def get_provider_impl(config, deps):
 
 class ProviderImpl(Providers):
     def __init__(self, config, deps):
-        self.config = config
+        self.stack_config = config.config
         self.deps = deps
 
     async def initialize(self) -> None:
@@ -41,8 +41,8 @@ class ProviderImpl(Providers):
         pass
 
     async def list_providers(self) -> ListProvidersResponse:
-        run_config = self.config.run_config
-        safe_config = StackRunConfig(**redact_sensitive_fields(run_config.model_dump()))
+        run_config = self.stack_config
+        safe_config = StackConfig(**redact_sensitive_fields(run_config.model_dump()))
         providers_health = await self.get_providers_health()
         ret = []
         for api, providers in safe_config.providers.items():

src/llama_stack/core/resolver.py

@@ -14,7 +14,7 @@ from llama_stack.core.datatypes import (
     AutoRoutedProviderSpec,
     Provider,
     RoutingTableProviderSpec,
-    StackRunConfig,
+    StackConfig,
 )
 from llama_stack.core.distribution import builtin_automatically_routed_apis
 from llama_stack.core.external import load_external_apis
@@ -147,7 +147,7 @@ ProviderRegistry = dict[Api, dict[str, ProviderSpec]]
 
 
 async def resolve_impls(
-    run_config: StackRunConfig,
+    run_config: StackConfig,
     provider_registry: ProviderRegistry,
     dist_registry: DistributionRegistry,
     policy: list[AccessRule],
@@ -217,7 +217,7 @@ def specs_for_autorouted_apis(apis_to_serve: list[str] | set[str]) -> dict[str,
 
 
 def validate_and_prepare_providers(
-    run_config: StackRunConfig, provider_registry: ProviderRegistry, routing_table_apis: set[Api], router_apis: set[Api]
+    run_config: StackConfig, provider_registry: ProviderRegistry, routing_table_apis: set[Api], router_apis: set[Api]
 ) -> dict[str, dict[str, ProviderWithSpec]]:
     """Validates providers, handles deprecations, and organizes them into a spec dictionary."""
     providers_with_specs: dict[str, dict[str, ProviderWithSpec]] = {}
@@ -261,7 +261,7 @@ def validate_provider(provider: Provider, api: Api, provider_registry: ProviderR
 
 
 def sort_providers_by_deps(
-    providers_with_specs: dict[str, dict[str, ProviderWithSpec]], run_config: StackRunConfig
+    providers_with_specs: dict[str, dict[str, ProviderWithSpec]], run_config: StackConfig
 ) -> list[tuple[str, ProviderWithSpec]]:
     """Sorts providers based on their dependencies."""
     sorted_providers: list[tuple[str, ProviderWithSpec]] = topological_sort(
@@ -278,7 +278,7 @@ async def instantiate_providers(
     sorted_providers: list[tuple[str, ProviderWithSpec]],
     router_apis: set[Api],
     dist_registry: DistributionRegistry,
-    run_config: StackRunConfig,
+    run_config: StackConfig,
     policy: list[AccessRule],
     internal_impls: dict[Api, Any] | None = None,
 ) -> dict[Api, Any]:
@@ -357,7 +357,7 @@ async def instantiate_provider(
     deps: dict[Api, Any],
     inner_impls: dict[str, Any],
     dist_registry: DistributionRegistry,
-    run_config: StackRunConfig,
+    run_config: StackConfig,
     policy: list[AccessRule],
 ):
     provider_spec = provider.spec

src/llama_stack/core/routers/__init__.py

@@ -9,8 +9,8 @@ from typing import Any
 from llama_stack.core.datatypes import (
     AccessRule,
     RoutedProtocol,
+    StackConfig,
 )
-from llama_stack.core.stack import StackRunConfig
 from llama_stack.core.store import DistributionRegistry
 from llama_stack.providers.utils.inference.inference_store import InferenceStore
 from llama_stack_api import Api, RoutingTable
@@ -51,7 +51,7 @@ async def get_routing_table_impl(
 
 
 async def get_auto_router_impl(
-    api: Api, routing_table: RoutingTable, deps: dict[str, Any], run_config: StackRunConfig, policy: list[AccessRule]
+    api: Api, routing_table: RoutingTable, deps: dict[str, Any], run_config: StackConfig, policy: list[AccessRule]
 ) -> Any:
     from .datasets import DatasetIORouter
     from .eval_scoring import EvalRouter, ScoringRouter

src/llama_stack/core/routing_tables/models.py

@@ -243,7 +243,7 @@ class ModelsRoutingTable(CommonRoutingTableImpl, Models):
         existing_models = await self.get_all_with_type("model")
 
         # we may have an alias for the model registered by the user (or during initialization
-        # from run.yaml) that we need to keep track of
+        # from config.yaml) that we need to keep track of
         model_ids = {}
         for model in existing_models:
             if model.provider_id != provider_id:

src/llama_stack/core/server/server.py

@@ -34,7 +34,7 @@ from pydantic import BaseModel, ValidationError
 from llama_stack.core.access_control.access_control import AccessDeniedError
 from llama_stack.core.datatypes import (
     AuthenticationRequiredError,
-    StackRunConfig,
+    StackConfig,
     process_cors_config,
 )
 from llama_stack.core.distribution import builtin_automatically_routed_apis
@@ -52,7 +52,7 @@ from llama_stack.core.stack import (
     replace_env_vars,
 )
 from llama_stack.core.utils.config import redact_sensitive_fields
-from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_distro
+from llama_stack.core.utils.config_resolution import resolve_config_or_distro
 from llama_stack.core.utils.context import preserve_contexts_async_generator
 from llama_stack.log import LoggingConfig, get_logger
 from llama_stack_api import Api, ConflictError, PaginatedResponse, ResourceNotFoundError
@@ -147,7 +147,7 @@ class StackApp(FastAPI):
     start background tasks (e.g. refresh model registry periodically) from the lifespan context manager.
     """
 
-    def __init__(self, config: StackRunConfig, *args, **kwargs):
+    def __init__(self, config: StackConfig, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.stack: Stack = Stack(config)
 
@@ -369,7 +369,7 @@ def create_app() -> StackApp:
     if config_file is None:
         raise ValueError("LLAMA_STACK_CONFIG environment variable is required")
 
-    config_file = resolve_config_or_distro(config_file, Mode.RUN)
+    config_file = resolve_config_or_distro(config_file)
 
     # Load and process configuration
     logger_config = None
@@ -380,7 +380,7 @@ def create_app() -> StackApp:
         logger = get_logger(name=__name__, category="core::server", config=logger_config)
 
         config = replace_env_vars(config_contents)
-        config = StackRunConfig(**cast_image_name_to_string(config))
+        config = StackConfig(**cast_image_name_to_string(config))
 
     _log_run_config(run_config=config)
 
@@ -510,7 +510,7 @@ def create_app() -> StackApp:
     return app
 
 
-def _log_run_config(run_config: StackRunConfig):
+def _log_run_config(run_config: StackConfig):
     """Logs the run config with redacted fields and disabled providers removed."""
     logger.info("Run configuration:")
     safe_config = redact_sensitive_fields(run_config.model_dump(mode="json"))

src/llama_stack/core/stack.py

@@ -14,7 +14,7 @@ from typing import Any
 import yaml
 
 from llama_stack.core.conversations.conversations import ConversationServiceConfig, ConversationServiceImpl
-from llama_stack.core.datatypes import Provider, SafetyConfig, StackRunConfig, VectorStoresConfig
+from llama_stack.core.datatypes import Provider, SafetyConfig, StackConfig, VectorStoresConfig
 from llama_stack.core.distribution import get_provider_registry
 from llama_stack.core.inspect import DistributionInspectConfig, DistributionInspectImpl
 from llama_stack.core.prompts.prompts import PromptServiceConfig, PromptServiceImpl
@@ -108,7 +108,7 @@ REGISTRY_REFRESH_TASK = None
 TEST_RECORDING_CONTEXT = None
 
 
-async def register_resources(run_config: StackRunConfig, impls: dict[Api, Any]):
+async def register_resources(run_config: StackConfig, impls: dict[Api, Any]):
     for rsrc, api, register_method, list_method in RESOURCES:
         objects = getattr(run_config.registered_resources, rsrc)
         if api not in impls:
@@ -341,7 +341,7 @@ def cast_image_name_to_string(config_dict: dict[str, Any]) -> dict[str, Any]:
     return config_dict
 
 
-def add_internal_implementations(impls: dict[Api, Any], run_config: StackRunConfig) -> None:
+def add_internal_implementations(impls: dict[Api, Any], config: StackConfig) -> None:
     """Add internal implementations (inspect and providers) to the implementations dictionary.
 
     Args:
@@ -349,31 +349,31 @@ def add_internal_implementations(impls: dict[Api, Any], run_config: StackRunConf
         run_config: Stack run configuration
     """
     inspect_impl = DistributionInspectImpl(
-        DistributionInspectConfig(run_config=run_config),
+        DistributionInspectConfig(config=config),
         deps=impls,
     )
     impls[Api.inspect] = inspect_impl
 
     providers_impl = ProviderImpl(
-        ProviderImplConfig(run_config=run_config),
+        ProviderImplConfig(config=config),
         deps=impls,
     )
     impls[Api.providers] = providers_impl
 
     prompts_impl = PromptServiceImpl(
-        PromptServiceConfig(run_config=run_config),
+        PromptServiceConfig(config=config),
         deps=impls,
     )
     impls[Api.prompts] = prompts_impl
 
     conversations_impl = ConversationServiceImpl(
-        ConversationServiceConfig(run_config=run_config),
+        ConversationServiceConfig(config=config),
         deps=impls,
     )
     impls[Api.conversations] = conversations_impl
 
 
-def _initialize_storage(run_config: StackRunConfig):
+def _initialize_storage(run_config: StackConfig):
     kv_backends: dict[str, StorageBackendConfig] = {}
     sql_backends: dict[str, StorageBackendConfig] = {}
     for backend_name, backend_config in run_config.storage.backends.items():
@@ -393,7 +393,7 @@ def _initialize_storage(run_config: StackRunConfig):
 
 
 class Stack:
-    def __init__(self, run_config: StackRunConfig, provider_registry: ProviderRegistry | None = None):
+    def __init__(self, run_config: StackConfig, provider_registry: ProviderRegistry | None = None):
         self.run_config = run_config
         self.provider_registry = provider_registry
         self.impls = None
@@ -499,20 +499,20 @@ async def refresh_registry_task(impls: dict[Api, Any]):
         await asyncio.sleep(REGISTRY_REFRESH_INTERVAL_SECONDS)
 
 
-def get_stack_run_config_from_distro(distro: str) -> StackRunConfig:
-    distro_path = importlib.resources.files("llama_stack") / f"distributions/{distro}/run.yaml"
+def get_stack_run_config_from_distro(distro: str) -> StackConfig:
+    distro_path = importlib.resources.files("llama_stack") / f"distributions/{distro}/config.yaml"
 
     with importlib.resources.as_file(distro_path) as path:
         if not path.exists():
             raise ValueError(f"Distribution '{distro}' not found at {distro_path}")
         run_config = yaml.safe_load(path.open())
 
-    return StackRunConfig(**replace_env_vars(run_config))
+    return StackConfig(**replace_env_vars(run_config))
 
 
 def run_config_from_adhoc_config_spec(
     adhoc_config_spec: str, provider_registry: ProviderRegistry | None = None
-) -> StackRunConfig:
+) -> StackConfig:
     """
     Create an adhoc distribution from a list of API providers.
 
@@ -552,7 +552,7 @@ def run_config_from_adhoc_config_spec(
                 config=provider_config,
             )
         ]
-    config = StackRunConfig(
+    config = StackConfig(
         image_name="distro-test",
         apis=list(provider_configs_by_api.keys()),
         providers=provider_configs_by_api,

src/llama_stack/core/utils/config_resolution.py

@@ -4,7 +4,6 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
-from enum import StrEnum
 from pathlib import Path
 
 from llama_stack.core.utils.config_dirs import DISTRIBS_BASE_DIR
@@ -16,21 +15,14 @@ logger = get_logger(name=__name__, category="core")
 DISTRO_DIR = Path(__file__).parent.parent.parent.parent / "llama_stack" / "distributions"
 
 
-class Mode(StrEnum):
-    RUN = "run"
-    BUILD = "build"
-
-
 def resolve_config_or_distro(
     config_or_distro: str,
-    mode: Mode = Mode.RUN,
 ) -> Path:
     """
     Resolve a config/distro argument to a concrete config file path.
 
     Args:
         config_or_distro: User input (file path, distribution name, or built distribution)
-        mode: Mode resolving for ("run", "build", "server")
 
     Returns:
         Path to the resolved config file
@@ -47,7 +39,7 @@ def resolve_config_or_distro(
 
     # Strategy 2: Try as distribution name (if no .yaml extension)
     if not config_or_distro.endswith(".yaml"):
-        distro_config = _get_distro_config_path(config_or_distro, mode)
+        distro_config = _get_distro_config_path(config_or_distro)
         if distro_config.exists():
             logger.debug(f"Using distribution: {distro_config}")
             return distro_config
@@ -63,34 +55,34 @@ def resolve_config_or_distro(
             return distro_config
 
     # Strategy 4: Try as built distribution name
-    distrib_config = DISTRIBS_BASE_DIR / f"llamastack-{config_or_distro}" / f"{config_or_distro}-{mode}.yaml"
+    distrib_config = DISTRIBS_BASE_DIR / f"llamastack-{config_or_distro}" / f"{config_or_distro}-config.yaml"
     if distrib_config.exists():
         logger.debug(f"Using built distribution: {distrib_config}")
         return distrib_config
 
-    distrib_config = DISTRIBS_BASE_DIR / f"{config_or_distro}" / f"{config_or_distro}-{mode}.yaml"
+    distrib_config = DISTRIBS_BASE_DIR / f"{config_or_distro}" / "config.yaml"
     if distrib_config.exists():
         logger.debug(f"Using built distribution: {distrib_config}")
         return distrib_config
 
     # Strategy 5: Failed - provide helpful error
-    raise ValueError(_format_resolution_error(config_or_distro, mode))
+    raise ValueError(_format_resolution_error(config_or_distro))
 
 
-def _get_distro_config_path(distro_name: str, mode: str) -> Path:
+def _get_distro_config_path(distro_name: str, path: str | None = None) -> Path:
     """Get the config file path for a distro."""
-    if not mode.endswith(".yaml"):
-        mode = f"{mode}.yaml"
-    return DISTRO_DIR / distro_name / mode
+    if not path or not path.endswith(".yaml"):
+        path = "config.yaml"
+    return DISTRO_DIR / distro_name / path
 
 
-def _format_resolution_error(config_or_distro: str, mode: Mode) -> str:
+def _format_resolution_error(config_or_distro: str) -> str:
     """Format a helpful error message for resolution failures."""
     from llama_stack.core.utils.config_dirs import DISTRIBS_BASE_DIR
 
-    distro_path = _get_distro_config_path(config_or_distro, mode)
-    distrib_path = DISTRIBS_BASE_DIR / f"llamastack-{config_or_distro}" / f"{config_or_distro}-{mode}.yaml"
-    distrib_path2 = DISTRIBS_BASE_DIR / f"{config_or_distro}" / f"{config_or_distro}-{mode}.yaml"
+    distro_path = _get_distro_config_path(config_or_distro)
+    distrib_path = DISTRIBS_BASE_DIR / f"llamastack-{config_or_distro}" / f"{config_or_distro}-config.yaml"
+    distrib_path2 = DISTRIBS_BASE_DIR / f"{config_or_distro}" / f"{config_or_distro}-config.yaml"
 
     available_distros = _get_available_distros()
     distros_str = ", ".join(available_distros) if available_distros else "none found"

src/llama_stack/distributions/ci-tests/build.yaml

@@ -1,60 +0,0 @@
-version: 2
-distribution_spec:
-  description: CI tests for Llama Stack
-  providers:
-    inference:
-    - provider_type: remote::cerebras
-    - provider_type: remote::ollama
-    - provider_type: remote::vllm
-    - provider_type: remote::tgi
-    - provider_type: remote::fireworks
-    - provider_type: remote::together
-    - provider_type: remote::bedrock
-    - provider_type: remote::nvidia
-    - provider_type: remote::openai
-    - provider_type: remote::anthropic
-    - provider_type: remote::gemini
-    - provider_type: remote::vertexai
-    - provider_type: remote::groq
-    - provider_type: remote::sambanova
-    - provider_type: remote::azure
-    - provider_type: inline::sentence-transformers
-    vector_io:
-    - provider_type: inline::faiss
-    - provider_type: inline::sqlite-vec
-    - provider_type: inline::milvus
-    - provider_type: remote::chromadb
-    - provider_type: remote::pgvector
-    - provider_type: remote::qdrant
-    - provider_type: remote::weaviate
-    files:
-    - provider_type: inline::localfs
-    safety:
-    - provider_type: inline::llama-guard
-    - provider_type: inline::code-scanner
-    agents:
-    - provider_type: inline::meta-reference
-    post_training:
-    - provider_type: inline::torchtune-cpu
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-    - provider_type: remote::model-context-protocol
-    batches:
-    - provider_type: inline::reference
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- asyncpg
-- psycopg2-binary
-- sqlalchemy[asyncio]

src/llama_stack/distributions/dell/build.yaml

@@ -1,33 +0,0 @@
-version: 2
-distribution_spec:
-  description: Dell's distribution of Llama Stack. TGI inference via Dell's custom
-    container
-  providers:
-    inference:
-    - provider_type: remote::tgi
-    - provider_type: inline::sentence-transformers
-    vector_io:
-    - provider_type: inline::faiss
-    - provider_type: remote::chromadb
-    - provider_type: remote::pgvector
-    safety:
-    - provider_type: inline::llama-guard
-    agents:
-    - provider_type: inline::meta-reference
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- sqlalchemy[asyncio]

src/llama_stack/distributions/dell/dell.py

@@ -111,7 +111,7 @@ def get_distribution_template() -> DistributionTemplate:
         container_image=None,
         providers=providers,
         run_configs={
-            "run.yaml": RunConfigSettings(
+            "config.yaml": RunConfigSettings(
                 provider_overrides={
                     "inference": [inference_provider, embedding_provider],
                     "vector_io": [chromadb_provider],

src/llama_stack/distributions/dell/doc_template.md

@@ -141,14 +141,14 @@ docker run \
   --pull always \
   -p $LLAMA_STACK_PORT:$LLAMA_STACK_PORT \
   -v $HOME/.llama:/root/.llama \
-  -v ./llama_stack/distributions/tgi/run-with-safety.yaml:/root/my-run.yaml \
+  -v ./llama_stack/distributions/tgi/run-with-safety.yaml:/root/my-config.yaml \
   -e INFERENCE_MODEL=$INFERENCE_MODEL \
   -e DEH_URL=$DEH_URL \
   -e SAFETY_MODEL=$SAFETY_MODEL \
   -e DEH_SAFETY_URL=$DEH_SAFETY_URL \
   -e CHROMA_URL=$CHROMA_URL \
   llamastack/distribution-{{ name }} \
-  --config /root/my-run.yaml \
+  --config /root/my-config.yaml \
   --port $LLAMA_STACK_PORT
 ```
 
@@ -157,16 +157,16 @@ docker run \
 You can also run the Docker container with a custom run configuration file by mounting it into the container:
 
 ```bash
-# Set the path to your custom run.yaml file
-CUSTOM_RUN_CONFIG=/path/to/your/custom-run.yaml
+# Set the path to your custom config.yaml file
+CUSTOM_RUN_CONFIG=/path/to/your/custom-config.yaml
 
 docker run -it \
   --pull always \
   --network host \
   -p $LLAMA_STACK_PORT:$LLAMA_STACK_PORT \
   -v $HOME/.llama:/root/.llama \
-  -v $CUSTOM_RUN_CONFIG:/app/custom-run.yaml \
-  -e RUN_CONFIG_PATH=/app/custom-run.yaml \
+  -v $CUSTOM_RUN_CONFIG:/app/custom-config.yaml \
+  -e RUN_CONFIG_PATH=/app/custom-config.yaml \
   -e INFERENCE_MODEL=$INFERENCE_MODEL \
   -e DEH_URL=$DEH_URL \
   -e CHROMA_URL=$CHROMA_URL \

src/llama_stack/distributions/meta-reference-gpu/build.yaml

@@ -1,32 +0,0 @@
-version: 2
-distribution_spec:
-  description: Use Meta Reference for running LLM inference
-  providers:
-    inference:
-    - provider_type: inline::meta-reference
-    vector_io:
-    - provider_type: inline::faiss
-    - provider_type: remote::chromadb
-    - provider_type: remote::pgvector
-    safety:
-    - provider_type: inline::llama-guard
-    agents:
-    - provider_type: inline::meta-reference
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-    - provider_type: remote::model-context-protocol
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- sqlalchemy[asyncio]

src/llama_stack/distributions/meta-reference-gpu/doc_template.md

@@ -73,8 +73,8 @@ docker run \
 You can also run the Docker container with a custom run configuration file by mounting it into the container:
 
 ```bash
-# Set the path to your custom run.yaml file
-CUSTOM_RUN_CONFIG=/path/to/your/custom-run.yaml
+# Set the path to your custom config.yaml file
+CUSTOM_RUN_CONFIG=/path/to/your/custom-config.yaml
 LLAMA_STACK_PORT=8321
 
 docker run \
@@ -83,8 +83,8 @@ docker run \
   --gpu all \
   -p $LLAMA_STACK_PORT:$LLAMA_STACK_PORT \
   -v ~/.llama:/root/.llama \
-  -v $CUSTOM_RUN_CONFIG:/app/custom-run.yaml \
-  -e RUN_CONFIG_PATH=/app/custom-run.yaml \
+  -v $CUSTOM_RUN_CONFIG:/app/custom-config.yaml \
+  -e RUN_CONFIG_PATH=/app/custom-config.yaml \
   llamastack/distribution-{{ name }} \
   --port $LLAMA_STACK_PORT
 ```
@@ -105,7 +105,7 @@ Make sure you have the Llama Stack CLI available.
 ```bash
 llama stack list-deps meta-reference-gpu | xargs -L1 uv pip install
 INFERENCE_MODEL=meta-llama/Llama-3.2-3B-Instruct \
-llama stack run distributions/{{ name }}/run.yaml \
+llama stack run distributions/{{ name }}/config.yaml \
   --port 8321
 ```
 

src/llama_stack/distributions/meta-reference-gpu/meta_reference.py

@@ -105,7 +105,7 @@ def get_distribution_template() -> DistributionTemplate:
         template_path=Path(__file__).parent / "doc_template.md",
         providers=providers,
         run_configs={
-            "run.yaml": RunConfigSettings(
+            "config.yaml": RunConfigSettings(
                 provider_overrides={
                     "inference": [inference_provider, embedding_provider],
                     "vector_io": [vector_io_provider],

src/llama_stack/distributions/nvidia/build.yaml

@@ -1,29 +0,0 @@
-version: 2
-distribution_spec:
-  description: Use NVIDIA NIM for running LLM inference, evaluation and safety
-  providers:
-    inference:
-    - provider_type: remote::nvidia
-    vector_io:
-    - provider_type: inline::faiss
-    safety:
-    - provider_type: remote::nvidia
-    agents:
-    - provider_type: inline::meta-reference
-    eval:
-    - provider_type: remote::nvidia
-    post_training:
-    - provider_type: remote::nvidia
-    datasetio:
-    - provider_type: inline::localfs
-    - provider_type: remote::nvidia
-    scoring:
-    - provider_type: inline::basic
-    tool_runtime:
-    - provider_type: inline::rag-runtime
-    files:
-    - provider_type: inline::localfs
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- sqlalchemy[asyncio]

src/llama_stack/distributions/nvidia/doc_template.md

@@ -128,8 +128,8 @@ docker run \
 You can also run the Docker container with a custom run configuration file by mounting it into the container:
 
 ```bash
-# Set the path to your custom run.yaml file
-CUSTOM_RUN_CONFIG=/path/to/your/custom-run.yaml
+# Set the path to your custom config.yaml file
+CUSTOM_RUN_CONFIG=/path/to/your/custom-config.yaml
 LLAMA_STACK_PORT=8321
 
 docker run \
@@ -137,8 +137,8 @@ docker run \
   --pull always \
   -p $LLAMA_STACK_PORT:$LLAMA_STACK_PORT \
   -v ~/.llama:/root/.llama \
-  -v $CUSTOM_RUN_CONFIG:/app/custom-run.yaml \
-  -e RUN_CONFIG_PATH=/app/custom-run.yaml \
+  -v $CUSTOM_RUN_CONFIG:/app/custom-config.yaml \
+  -e RUN_CONFIG_PATH=/app/custom-config.yaml \
   -e NVIDIA_API_KEY=$NVIDIA_API_KEY \
   llamastack/distribution-{{ name }} \
   --port $LLAMA_STACK_PORT
@@ -162,7 +162,7 @@ INFERENCE_MODEL=meta-llama/Llama-3.1-8B-Instruct
 llama stack list-deps nvidia | xargs -L1 uv pip install
 NVIDIA_API_KEY=$NVIDIA_API_KEY \
 INFERENCE_MODEL=$INFERENCE_MODEL \
-llama stack run ./run.yaml \
+llama stack run ./config.yaml \
   --port 8321
 ```
 

src/llama_stack/distributions/nvidia/nvidia.py

@@ -81,7 +81,7 @@ def get_distribution_template(name: str = "nvidia") -> DistributionTemplate:
         template_path=Path(__file__).parent / "doc_template.md",
         providers=providers,
         run_configs={
-            "run.yaml": RunConfigSettings(
+            "config.yaml": RunConfigSettings(
                 provider_overrides={
                     "inference": [inference_provider],
                     "datasetio": [datasetio_provider],

src/llama_stack/distributions/oci/build.yaml

@@ -1,35 +0,0 @@
-version: 2
-distribution_spec:
-  description: Use Oracle Cloud Infrastructure (OCI) Generative AI for running LLM
-    inference with scalable cloud services
-  providers:
-    inference:
-    - provider_type: remote::oci
-    vector_io:
-    - provider_type: inline::faiss
-    - provider_type: remote::chromadb
-    - provider_type: remote::pgvector
-    safety:
-    - provider_type: inline::llama-guard
-    agents:
-    - provider_type: inline::meta-reference
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-    - provider_type: remote::model-context-protocol
-    files:
-    - provider_type: inline::localfs
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- sqlalchemy[asyncio]

src/llama_stack/distributions/oci/oci.py

@@ -74,7 +74,7 @@ def get_distribution_template(name: str = "oci") -> DistributionTemplate:
         template_path=Path(__file__).parent / "doc_template.md",
         providers=providers,
         run_configs={
-            "run.yaml": RunConfigSettings(
+            "config.yaml": RunConfigSettings(
                 provider_overrides={
                     "inference": [inference_provider],
                     "vector_io": [vector_io_provider],

src/llama_stack/distributions/open-benchmark/build.yaml

@@ -1,36 +0,0 @@
-version: 2
-distribution_spec:
-  description: Distribution for running open benchmarks
-  providers:
-    inference:
-    - provider_type: remote::openai
-    - provider_type: remote::anthropic
-    - provider_type: remote::gemini
-    - provider_type: remote::groq
-    - provider_type: remote::together
-    vector_io:
-    - provider_type: inline::sqlite-vec
-    - provider_type: remote::chromadb
-    - provider_type: remote::pgvector
-    safety:
-    - provider_type: inline::llama-guard
-    agents:
-    - provider_type: inline::meta-reference
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-    - provider_type: remote::model-context-protocol
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- sqlalchemy[asyncio]

src/llama_stack/distributions/open-benchmark/open_benchmark.py

@@ -261,7 +261,7 @@ def get_distribution_template() -> DistributionTemplate:
         providers=providers,
         available_models_by_provider=available_models,
         run_configs={
-            "run.yaml": RunConfigSettings(
+            "config.yaml": RunConfigSettings(
                 provider_overrides={
                     "inference": inference_providers,
                     "vector_io": vector_io_providers,

src/llama_stack/distributions/starter-gpu/build.yaml

@@ -1,61 +0,0 @@
-version: 2
-distribution_spec:
-  description: Quick start template for running Llama Stack with several popular providers.
-    This distribution is intended for GPU-enabled environments.
-  providers:
-    inference:
-    - provider_type: remote::cerebras
-    - provider_type: remote::ollama
-    - provider_type: remote::vllm
-    - provider_type: remote::tgi
-    - provider_type: remote::fireworks
-    - provider_type: remote::together
-    - provider_type: remote::bedrock
-    - provider_type: remote::nvidia
-    - provider_type: remote::openai
-    - provider_type: remote::anthropic
-    - provider_type: remote::gemini
-    - provider_type: remote::vertexai
-    - provider_type: remote::groq
-    - provider_type: remote::sambanova
-    - provider_type: remote::azure
-    - provider_type: inline::sentence-transformers
-    vector_io:
-    - provider_type: inline::faiss
-    - provider_type: inline::sqlite-vec
-    - provider_type: inline::milvus
-    - provider_type: remote::chromadb
-    - provider_type: remote::pgvector
-    - provider_type: remote::qdrant
-    - provider_type: remote::weaviate
-    files:
-    - provider_type: inline::localfs
-    safety:
-    - provider_type: inline::llama-guard
-    - provider_type: inline::code-scanner
-    agents:
-    - provider_type: inline::meta-reference
-    post_training:
-    - provider_type: inline::huggingface-gpu
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-    - provider_type: remote::model-context-protocol
-    batches:
-    - provider_type: inline::reference
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- asyncpg
-- psycopg2-binary
-- sqlalchemy[asyncio]

src/llama_stack/distributions/starter/build.yaml

@@ -1,61 +0,0 @@
-version: 2
-distribution_spec:
-  description: Quick start template for running Llama Stack with several popular providers.
-    This distribution is intended for CPU-only environments.
-  providers:
-    inference:
-    - provider_type: remote::cerebras
-    - provider_type: remote::ollama
-    - provider_type: remote::vllm
-    - provider_type: remote::tgi
-    - provider_type: remote::fireworks
-    - provider_type: remote::together
-    - provider_type: remote::bedrock
-    - provider_type: remote::nvidia
-    - provider_type: remote::openai
-    - provider_type: remote::anthropic
-    - provider_type: remote::gemini
-    - provider_type: remote::vertexai
-    - provider_type: remote::groq
-    - provider_type: remote::sambanova
-    - provider_type: remote::azure
-    - provider_type: inline::sentence-transformers
-    vector_io:
-    - provider_type: inline::faiss
-    - provider_type: inline::sqlite-vec
-    - provider_type: inline::milvus
-    - provider_type: remote::chromadb
-    - provider_type: remote::pgvector
-    - provider_type: remote::qdrant
-    - provider_type: remote::weaviate
-    files:
-    - provider_type: inline::localfs
-    safety:
-    - provider_type: inline::llama-guard
-    - provider_type: inline::code-scanner
-    agents:
-    - provider_type: inline::meta-reference
-    post_training:
-    - provider_type: inline::torchtune-cpu
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-    - provider_type: remote::model-context-protocol
-    batches:
-    - provider_type: inline::reference
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- asyncpg
-- psycopg2-binary
-- sqlalchemy[asyncio]

src/llama_stack/distributions/starter/starter.py

@@ -275,9 +275,8 @@ def get_distribution_template(name: str = "starter") -> DistributionTemplate:
         container_image=None,
         template_path=None,
         providers=providers,
-        additional_pip_packages=list(set(PostgresSqlStoreConfig.pip_packages() + PostgresKVStoreConfig.pip_packages())),
         run_configs={
-            "run.yaml": base_run_settings,
+            "config.yaml": base_run_settings,
             "run-with-postgres-store.yaml": postgres_run_settings,
         },
         run_config_env_vars={

src/llama_stack/distributions/template.py

@@ -16,10 +16,8 @@ from llama_stack.core.datatypes import (
     LLAMA_STACK_RUN_CONFIG_VERSION,
     Api,
     BenchmarkInput,
-    BuildConfig,
     BuildProvider,
     DatasetInput,
-    DistributionSpec,
     ModelInput,
     Provider,
     SafetyConfig,
@@ -35,11 +33,8 @@ from llama_stack.core.storage.datatypes import (
     StorageBackendType,
 )
 from llama_stack.core.storage.kvstore.config import SqliteKVStoreConfig
-from llama_stack.core.storage.kvstore.config import get_pip_packages as get_kv_pip_packages
 from llama_stack.core.storage.sqlstore.sqlstore import SqliteSqlStoreConfig
-from llama_stack.core.storage.sqlstore.sqlstore import get_pip_packages as get_sql_pip_packages
 from llama_stack.core.utils.dynamic import instantiate_class_type
-from llama_stack.core.utils.image_types import LlamaStackImageType
 from llama_stack.providers.utils.inference.model_registry import ProviderModelEntry
 from llama_stack_api import DatasetPurpose, ModelType
 
@@ -319,55 +314,6 @@ class DistributionTemplate(BaseModel):
 
     available_models_by_provider: dict[str, list[ProviderModelEntry]] | None = None
 
-    # we may want to specify additional pip packages without necessarily indicating a
-    # specific "default" inference store (which is what typically used to dictate additional
-    # pip packages)
-    additional_pip_packages: list[str] | None = None
-
-    def build_config(self) -> BuildConfig:
-        additional_pip_packages: list[str] = []
-        for run_config in self.run_configs.values():
-            run_config_ = run_config.run_config(self.name, self.providers, self.container_image)
-
-            # TODO: This is a hack to get the dependencies for internal APIs into build
-            # We should have a better way to do this by formalizing the concept of "internal" APIs
-            # and providers, with a way to specify dependencies for them.
-
-            storage_cfg = run_config_.get("storage", {})
-            for backend_cfg in storage_cfg.get("backends", {}).values():
-                store_type = backend_cfg.get("type")
-                if not store_type:
-                    continue
-                if str(store_type).startswith("kv_"):
-                    additional_pip_packages.extend(get_kv_pip_packages(backend_cfg))
-                elif str(store_type).startswith("sql_"):
-                    additional_pip_packages.extend(get_sql_pip_packages(backend_cfg))
-
-        if self.additional_pip_packages:
-            additional_pip_packages.extend(self.additional_pip_packages)
-
-        # Create minimal providers for build config (without runtime configs)
-        build_providers = {}
-        for api, providers in self.providers.items():
-            build_providers[api] = []
-            for provider in providers:
-                # Create a minimal build provider object with only essential build information
-                build_provider = BuildProvider(
-                    provider_type=provider.provider_type,
-                    module=provider.module,
-                )
-                build_providers[api].append(build_provider)
-
-        return BuildConfig(
-            distribution_spec=DistributionSpec(
-                description=self.description,
-                container_image=self.container_image,
-                providers=build_providers,
-            ),
-            image_type=LlamaStackImageType.VENV.value,  # default to venv
-            additional_pip_packages=sorted(set(additional_pip_packages)),
-        )
-
     def generate_markdown_docs(self) -> str:
         providers_table = "| API | Provider(s) |\n"
         providers_table += "|-----|-------------|\n"
@@ -439,14 +385,6 @@ class DistributionTemplate(BaseModel):
         for output_dir in [yaml_output_dir, doc_output_dir]:
             output_dir.mkdir(parents=True, exist_ok=True)
 
-        build_config = self.build_config()
-        with open(yaml_output_dir / "build.yaml", "w") as f:
-            yaml.safe_dump(
-                filter_empty_values(build_config.model_dump(exclude_none=True)),
-                f,
-                sort_keys=False,
-            )
-
         for yaml_pth, settings in self.run_configs.items():
             run_config = settings.run_config(self.name, self.providers, self.container_image)
             with open(yaml_output_dir / yaml_pth, "w") as f:

src/llama_stack/distributions/watsonx/build.yaml

@@ -1,33 +0,0 @@
-version: 2
-distribution_spec:
-  description: Use watsonx for running LLM inference
-  providers:
-    inference:
-    - provider_type: remote::watsonx
-    - provider_type: inline::sentence-transformers
-    vector_io:
-    - provider_type: inline::faiss
-    safety:
-    - provider_type: inline::llama-guard
-    agents:
-    - provider_type: inline::meta-reference
-    eval:
-    - provider_type: inline::meta-reference
-    datasetio:
-    - provider_type: remote::huggingface
-    - provider_type: inline::localfs
-    scoring:
-    - provider_type: inline::basic
-    - provider_type: inline::llm-as-judge
-    - provider_type: inline::braintrust
-    tool_runtime:
-    - provider_type: remote::brave-search
-    - provider_type: remote::tavily-search
-    - provider_type: inline::rag-runtime
-    - provider_type: remote::model-context-protocol
-    files:
-    - provider_type: inline::localfs
-image_type: venv
-additional_pip_packages:
-- aiosqlite
-- sqlalchemy[asyncio]

src/llama_stack/distributions/watsonx/watsonx.py

@@ -69,7 +69,7 @@ def get_distribution_template(name: str = "watsonx") -> DistributionTemplate:
         template_path=None,
         providers=providers,
         run_configs={
-            "run.yaml": RunConfigSettings(
+            "config.yaml": RunConfigSettings(
                 provider_overrides={
                     "inference": [inference_provider],
                     "files": [files_provider],

src/llama_stack/log.py

@@ -91,10 +91,10 @@ def config_to_category_levels(category: str, level: str):
 
 def parse_yaml_config(yaml_config: LoggingConfig) -> dict[str, int]:
     """
-    Helper function to parse a yaml logging configuration found in the run.yaml
+    Helper function to parse a yaml logging configuration found in the config.yaml
 
     Parameters:
-        yaml_config (Logging): the logger config object found in the run.yaml
+        yaml_config (Logging): the logger config object found in the config.yaml
 
     Returns:
         Dict[str, int]: A dictionary mapping categories to their log levels.

src/llama_stack/providers/inline/inference/meta_reference/config.py

@@ -16,7 +16,7 @@ class MetaReferenceInferenceConfig(BaseModel):
     # this is a placeholder to indicate inference model id
     # the actual inference model id is dtermined by the moddel id in the request
     # Note: you need to register the model before using it for inference
-    # models in the resouce list in the run.yaml config will be registered automatically
+    # models in the resouce list in the config.yaml config will be registered automatically
     model: str | None = None
     torch_seed: int | None = None
     max_seq_len: int = 4096

src/llama_stack/providers/remote/inference/tgi/tgi.py

@@ -51,7 +51,9 @@ class _HfAdapter(OpenAIMixin):
 class TGIAdapter(_HfAdapter):
     async def initialize(self, config: TGIImplConfig) -> None:
         if not config.base_url:
-            raise ValueError("You must provide a URL in run.yaml (or via the TGI_URL environment variable) to use TGI.")
+            raise ValueError(
+                "You must provide a URL in config.yaml (or via the TGI_URL environment variable) to use TGI."
+            )
         log.info(f"Initializing TGI client with url={config.base_url}")
         # Extract base URL without /v1 for HF client initialization
         base_url_str = str(config.base_url).rstrip("/")

src/llama_stack/providers/remote/inference/vllm/vllm.py

@@ -46,7 +46,7 @@ class VLLMInferenceAdapter(OpenAIMixin):
     async def initialize(self) -> None:
         if not self.config.base_url:
             raise ValueError(
-                "You must provide a URL in run.yaml (or via the VLLM_URL environment variable) to use vLLM."
+                "You must provide a URL in config.yaml (or via the VLLM_URL environment variable) to use vLLM."
             )
 
     async def health(self) -> HealthResponse: