chore: rename templates to distributions (#3035)

As the title says. Distributions is in, Templates is out.

`llama stack build --template` --> `llama stack build --distro`. For
backward compatibility, the previous option is kept but results in a
warning.

Updated `server.py` to remove the "config_or_template" backward
compatibility since it has been a couple releases since that change.

llama_stack/cli/stack/_build.py

@@ -46,25 +46,25 @@ from llama_stack.core.utils.exec import formulate_run_args, run_command
 from llama_stack.core.utils.image_types import LlamaStackImageType
 from llama_stack.providers.datatypes import Api
 
-TEMPLATES_PATH = Path(__file__).parent.parent.parent / "templates"
+DISTRIBS_PATH = Path(__file__).parent.parent.parent / "distributions"
 
 
 @lru_cache
-def available_templates_specs() -> dict[str, BuildConfig]:
+def available_distros_specs() -> dict[str, BuildConfig]:
     import yaml
 
-    template_specs = {}
-    for p in TEMPLATES_PATH.rglob("*build.yaml"):
-        template_name = p.parent.name
+    distro_specs = {}
+    for p in DISTRIBS_PATH.rglob("*build.yaml"):
+        distro_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
+            distro_specs[distro_name] = build_config
+    return distro_specs
 
 
 def run_stack_build_command(args: argparse.Namespace) -> None:
-    if args.list_templates:
-        return _run_template_list_cmd()
+    if args.list_distros:
+        return _run_distro_list_cmd()
 
     if args.image_type == ImageType.VENV.value:
         current_venv = os.environ.get("VIRTUAL_ENV")
@@ -73,20 +73,30 @@ def run_stack_build_command(args: argparse.Namespace) -> None:
         image_name = args.image_name
 
     if args.template:
-        available_templates = available_templates_specs()
-        if args.template not in available_templates:
+        cprint(
+            "The --template argument is deprecated. Please use --distro instead.",
+            color="red",
+            file=sys.stderr,
+        )
+        distro_name = args.template
+    else:
+        distro_name = args.distribution
+
+    if distro_name:
+        available_distros = available_distros_specs()
+        if distro_name not in available_distros:
             cprint(
-                f"Could not find template {args.template}. Please run `llama stack build --list-templates` to check out the available templates",
+                f"Could not find distribution {distro_name}. Please run `llama stack build --list-distros` to check out the available distributions",
                 color="red",
                 file=sys.stderr,
             )
             sys.exit(1)
-        build_config = available_templates[args.template]
+        build_config = available_distros[distro_name]
         if args.image_type:
             build_config.image_type = args.image_type
         else:
             cprint(
-                f"Please specify a image-type ({' | '.join(e.value for e in ImageType)}) for {args.template}",
+                f"Please specify a image-type ({' | '.join(e.value for e in ImageType)}) for {distro_name}",
                 color="red",
                 file=sys.stderr,
             )
@@ -136,7 +146,7 @@ def run_stack_build_command(args: argparse.Namespace) -> None:
             sys.exit(1)
 
         build_config = BuildConfig(image_type=args.image_type, distribution_spec=distribution_spec)
-    elif not args.config and not args.template:
+    elif not args.config and not distro_name:
         name = prompt(
             "> Enter a name for your Llama Stack (e.g. my-local-stack): ",
             validator=Validator.from_callable(
@@ -218,7 +228,7 @@ def run_stack_build_command(args: argparse.Namespace) -> None:
                 sys.exit(1)
 
     if args.print_deps_only:
-        print(f"# Dependencies for {args.template or args.config or image_name}")
+        print(f"# Dependencies for {distro_name or args.config or image_name}")
         normal_deps, special_deps, external_provider_dependencies = get_provider_dependencies(build_config)
         normal_deps += SERVER_DEPENDENCIES
         print(f"uv pip install {' '.join(normal_deps)}")
@@ -233,7 +243,7 @@ def run_stack_build_command(args: argparse.Namespace) -> None:
             build_config,
             image_name=image_name,
             config_path=args.config,
-            template_name=args.template,
+            distro_name=distro_name,
         )
 
     except (Exception, RuntimeError) as exc:
@@ -344,13 +354,13 @@ def _generate_run_config(
 def _run_stack_build_command_from_build_config(
     build_config: BuildConfig,
     image_name: str | None = None,
-    template_name: str | None = None,
+    distro_name: str | None = None,
     config_path: str | None = None,
 ) -> Path | Traversable:
     image_name = image_name or build_config.image_name
     if build_config.image_type == LlamaStackImageType.CONTAINER.value:
-        if template_name:
-            image_name = f"distribution-{template_name}"
+        if distro_name:
+            image_name = f"distribution-{distro_name}"
         else:
             if not image_name:
                 raise ValueError("Please specify an image name when building a container image without a template")
@@ -364,9 +374,9 @@ def _run_stack_build_command_from_build_config(
     if image_name is None:
         raise ValueError("image_name should not be None after validation")
 
-    if template_name:
-        build_dir = DISTRIBS_BASE_DIR / template_name
-        build_file_path = build_dir / f"{template_name}-build.yaml"
+    if distro_name:
+        build_dir = DISTRIBS_BASE_DIR / distro_name
+        build_file_path = build_dir / f"{distro_name}-build.yaml"
     else:
         if image_name is None:
             raise ValueError("image_name cannot be None")
@@ -377,7 +387,7 @@ def _run_stack_build_command_from_build_config(
     run_config_file = None
     # Generate the run.yaml so it can be included in the container image with the proper entrypoint
     # Only do this if we're building a container image and we're not using a template
-    if build_config.image_type == LlamaStackImageType.CONTAINER.value and not template_name and config_path:
+    if build_config.image_type == LlamaStackImageType.CONTAINER.value and not distro_name and config_path:
         cprint("Generating run.yaml file", color="yellow", file=sys.stderr)
         run_config_file = _generate_run_config(build_config, build_dir, image_name)
 
@@ -411,46 +421,45 @@ def _run_stack_build_command_from_build_config(
     return_code = build_image(
         build_config,
         image_name,
-        template_or_config=template_name or config_path or str(build_file_path),
+        distro_or_config=distro_name or config_path or str(build_file_path),
         run_config=run_config_file.as_posix() if run_config_file else None,
     )
     if return_code != 0:
         raise RuntimeError(f"Failed to build image {image_name}")
 
-    if template_name:
-        # copy run.yaml from template to build_dir instead of generating it again
-        template_path = importlib.resources.files("llama_stack") / f"templates/{template_name}/run.yaml"
-        run_config_file = build_dir / f"{template_name}-run.yaml"
+    if distro_name:
+        # copy run.yaml from distribution to build_dir instead of generating it again
+        distro_path = importlib.resources.files("llama_stack") / f"distributions/{distro_name}/run.yaml"
+        run_config_file = build_dir / f"{distro_name}-run.yaml"
 
-        with importlib.resources.as_file(template_path) as path:
+        with importlib.resources.as_file(distro_path) as path:
             shutil.copy(path, run_config_file)
 
         cprint("Build Successful!", color="green", file=sys.stderr)
-        cprint(f"You can find the newly-built template here: {run_config_file}", color="blue", file=sys.stderr)
+        cprint(f"You can find the newly-built distribution here: {run_config_file}", color="blue", file=sys.stderr)
         cprint(
             "You can run the new Llama Stack distro via: "
             + colored(f"llama stack run {run_config_file} --image-type {build_config.image_type}", "blue"),
             color="green",
             file=sys.stderr,
         )
-        return template_path
+        return distro_path
     else:
         return _generate_run_config(build_config, build_dir, image_name)
 
 
-def _run_template_list_cmd() -> None:
-    # eventually, this should query a registry at llama.meta.com/llamastack/distributions
+def _run_distro_list_cmd() -> None:
     headers = [
-        "Template Name",
+        "Distribution Name",
         # "Providers",
         "Description",
     ]
 
     rows = []
-    for template_name, spec in available_templates_specs().items():
+    for distro_name, spec in available_distros_specs().items():
         rows.append(
             [
-                template_name,
+                distro_name,
                 # json.dumps(spec.distribution_spec.providers, indent=2),
                 spec.distribution_spec.description,
             ]

llama_stack/cli/stack/build.py

@@ -34,14 +34,24 @@ class StackBuild(Subcommand):
             "--template",
             type=str,
             default=None,
-            help="Name of the example template config to use for build. You may use `llama stack build --list-templates` to check out the available templates",
+            help="""(deprecated) Name of the example template config to use for build. You may use `llama stack build --list-distros` to check out the available distributions""",
+        )
+        self.parser.add_argument(
+            "--distro",
+            "--distribution",
+            dest="distribution",
+            type=str,
+            default=None,
+            help="""Name of the distribution to use for build. You may use `llama stack build --list-distros` to check out the available distributions""",
         )
 
         self.parser.add_argument(
-            "--list-templates",
+            "--list-distros",
+            "--list-distributions",
             action="store_true",
+            dest="list_distros",
             default=False,
-            help="Show the available templates for building a Llama Stack distribution",
+            help="Show the available distributions for building a Llama Stack distribution",
         )
 
         self.parser.add_argument(

llama_stack/cli/stack/run.py

@@ -35,8 +35,8 @@ class StackRun(Subcommand):
             "config",
             type=str,
             nargs="?",  # Make it optional
-            metavar="config | template",
-            help="Path to config file to use for the run or name of known template (`llama stack list` for a list).",
+            metavar="config | distro",
+            help="Path to config file to use for the run or name of known distro (`llama stack list` for a list).",
         )
         self.parser.add_argument(
             "--port",
@@ -68,22 +68,22 @@ class StackRun(Subcommand):
             help="Start the UI server",
         )
 
-    def _resolve_config_and_template(self, args: argparse.Namespace) -> tuple[Path | None, str | None]:
-        """Resolve config file path and template name from args.config"""
-        from llama_stack.distribution.utils.config_dirs import DISTRIBS_BASE_DIR
+    def _resolve_config_and_distro(self, args: argparse.Namespace) -> tuple[Path | None, str | None]:
+        """Resolve config file path and distribution name from args.config"""
+        from llama_stack.core.utils.config_dirs import DISTRIBS_BASE_DIR
 
         if not args.config:
             return None, None
 
         config_file = Path(args.config)
         has_yaml_suffix = args.config.endswith(".yaml")
-        template_name = None
+        distro_name = None
 
         if not config_file.exists() and not has_yaml_suffix:
-            # check if this is a template
-            config_file = Path(REPO_ROOT) / "llama_stack" / "templates" / args.config / "run.yaml"
+            # check if this is a distribution
+            config_file = Path(REPO_ROOT) / "llama_stack" / "distributions" / args.config / "run.yaml"
             if config_file.exists():
-                template_name = args.config
+                distro_name = args.config
 
         if not config_file.exists() and not has_yaml_suffix:
             # check if it's a build config saved to ~/.llama dir
@@ -99,7 +99,7 @@ class StackRun(Subcommand):
                 f"Config file must be a valid file path, '{config_file}' is not a file: type={type(config_file)}"
             )
 
-        return config_file, template_name
+        return config_file, distro_name
 
     def _run_stack_run_cmd(self, args: argparse.Namespace) -> None:
         import yaml
@@ -113,9 +113,9 @@ class StackRun(Subcommand):
 
         if args.config:
             try:
-                from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_template
+                from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_distro
 
-                config_file = resolve_config_or_template(args.config, Mode.RUN)
+                config_file = resolve_config_or_distro(args.config, Mode.RUN)
             except ValueError as e:
                 self.parser.error(str(e))
         else:

llama_stack/cli/utils.py

@@ -11,38 +11,19 @@ from llama_stack.log import get_logger
 logger = get_logger(name=__name__, category="cli")
 
 
-def add_config_template_args(parser: argparse.ArgumentParser):
-    """Add unified config/template arguments with backward compatibility."""
+# TODO: this can probably just be inlined now?
+def add_config_distro_args(parser: argparse.ArgumentParser):
+    """Add unified config/distro arguments."""
     group = parser.add_mutually_exclusive_group(required=True)
 
     group.add_argument(
         "config",
         nargs="?",
-        help="Configuration file path or template name",
-    )
-
-    # Backward compatibility arguments (deprecated)
-    group.add_argument(
-        "--config",
-        dest="config_deprecated",
-        help="(DEPRECATED) Use positional argument [config] instead. Configuration file path",
-    )
-
-    group.add_argument(
-        "--template",
-        dest="template_deprecated",
-        help="(DEPRECATED) Use positional argument [config] instead. Template name",
+        help="Configuration file path or distribution name",
     )
 
 
 def get_config_from_args(args: argparse.Namespace) -> str | None:
-    """Extract config value from parsed arguments, handling both new and deprecated forms."""
     if args.config is not None:
         return str(args.config)
-    elif hasattr(args, "config_deprecated") and args.config_deprecated is not None:
-        logger.warning("Using deprecated --config argument. Use positional argument [config] instead.")
-        return str(args.config_deprecated)
-    elif hasattr(args, "template_deprecated") and args.template_deprecated is not None:
-        logger.warning("Using deprecated --template argument. Use positional argument [config] instead.")
-        return str(args.template_deprecated)
     return None

llama_stack/core/build.py

@@ -16,8 +16,8 @@ from llama_stack.core.distribution import get_provider_registry
 from llama_stack.core.external import load_external_apis
 from llama_stack.core.utils.exec import run_command
 from llama_stack.core.utils.image_types import LlamaStackImageType
+from llama_stack.distributions.template import DistributionTemplate
 from llama_stack.providers.datatypes import Api
-from llama_stack.templates.template import DistributionTemplate
 
 log = logging.getLogger(__name__)
 
@@ -106,7 +106,7 @@ def print_pip_install_help(config: BuildConfig):
 def build_image(
     build_config: BuildConfig,
     image_name: str,
-    template_or_config: str,
+    distro_or_config: str,
     run_config: str | None = None,
 ):
     container_base = build_config.distribution_spec.container_image or "python:3.12-slim"
@@ -123,8 +123,8 @@ def build_image(
         script = str(importlib.resources.files("llama_stack") / "core/build_container.sh")
         args = [
             script,
-            "--template-or-config",
-            template_or_config,
+            "--distro-or-config",
+            distro_or_config,
             "--image-name",
             image_name,
             "--container-base",

llama_stack/core/build_container.sh

@@ -43,7 +43,7 @@ normal_deps=""
 external_provider_deps=""
 optional_deps=""
 run_config=""
-template_or_config=""
+distro_or_config=""
 
 while [[ $# -gt 0 ]]; do
   key="$1"
@@ -96,12 +96,12 @@ while [[ $# -gt 0 ]]; do
       run_config="$2"
       shift 2
       ;;
-    --template-or-config)
+    --distro-or-config)
       if [[ -z "$2" || "$2" == --* ]]; then
-        echo "Error: --template-or-config requires a string value" >&2
+        echo "Error: --distro-or-config requires a string value" >&2
         usage
       fi
-      template_or_config="$2"
+      distro_or_config="$2"
       shift 2
       ;;
     *)
@@ -327,12 +327,11 @@ EOF
 # If a run config is provided, we use the --config flag
 if [[ -n "$run_config" ]]; then
   add_to_container << EOF
-ENTRYPOINT ["python", "-m", "llama_stack.core.server.server", "--config", "$RUN_CONFIG_PATH"]
+ENTRYPOINT ["python", "-m", "llama_stack.core.server.server", "$RUN_CONFIG_PATH"]
 EOF
-# If a template is provided (not a yaml file), we use the --template flag
-elif [[ "$template_or_config" != *.yaml ]]; then
+elif [[ "$distro_or_config" != *.yaml ]]; then
   add_to_container << EOF
-ENTRYPOINT ["python", "-m", "llama_stack.core.server.server", "--template", "$template_or_config"]
+ENTRYPOINT ["python", "-m", "llama_stack.core.server.server", "$distro_or_config"]
 EOF
 fi
 

llama_stack/core/library_client.py

@@ -42,7 +42,7 @@ from llama_stack.core.resolver import ProviderRegistry
 from llama_stack.core.server.routes import RouteImpls, find_matching_route, initialize_route_impls
 from llama_stack.core.stack import (
     construct_stack,
-    get_stack_run_config_from_template,
+    get_stack_run_config_from_distro,
     replace_env_vars,
 )
 from llama_stack.core.utils.config import redact_sensitive_fields
@@ -138,14 +138,14 @@ class LibraryClientHttpxResponse:
 class LlamaStackAsLibraryClient(LlamaStackClient):
     def __init__(
         self,
-        config_path_or_template_name: str,
+        config_path_or_distro_name: str,
         skip_logger_removal: bool = False,
         custom_provider_registry: ProviderRegistry | None = None,
         provider_data: dict[str, Any] | None = None,
     ):
         super().__init__()
         self.async_client = AsyncLlamaStackAsLibraryClient(
-            config_path_or_template_name, custom_provider_registry, provider_data
+            config_path_or_distro_name, custom_provider_registry, provider_data
         )
         self.pool_executor = ThreadPoolExecutor(max_workers=4)
         self.skip_logger_removal = skip_logger_removal
@@ -212,7 +212,7 @@ class LlamaStackAsLibraryClient(LlamaStackClient):
 class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
     def __init__(
         self,
-        config_path_or_template_name: str,
+        config_path_or_distro_name: str,
         custom_provider_registry: ProviderRegistry | None = None,
         provider_data: dict[str, Any] | None = None,
     ):
@@ -222,17 +222,17 @@ class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
         current_sinks = os.environ.get("TELEMETRY_SINKS", "sqlite").split(",")
         os.environ["TELEMETRY_SINKS"] = ",".join(sink for sink in current_sinks if sink != "console")
 
-        if config_path_or_template_name.endswith(".yaml"):
-            config_path = Path(config_path_or_template_name)
+        if config_path_or_distro_name.endswith(".yaml"):
+            config_path = Path(config_path_or_distro_name)
             if not config_path.exists():
                 raise ValueError(f"Config file {config_path} does not exist")
             config_dict = replace_env_vars(yaml.safe_load(config_path.read_text()))
             config = parse_and_maybe_upgrade_config(config_dict)
         else:
-            # template
-            config = get_stack_run_config_from_template(config_path_or_template_name)
+            # distribution
+            config = get_stack_run_config_from_distro(config_path_or_distro_name)
 
-        self.config_path_or_template_name = config_path_or_template_name
+        self.config_path_or_distro_name = config_path_or_distro_name
         self.config = config
         self.custom_provider_registry = custom_provider_registry
         self.provider_data = provider_data
@@ -245,11 +245,11 @@ class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
         except ModuleNotFoundError as _e:
             cprint(_e.msg, color="red", file=sys.stderr)
             cprint(
-                "Using llama-stack as a library requires installing dependencies depending on the template (providers) you choose.\n",
+                "Using llama-stack as a library requires installing dependencies depending on the distribution (providers) you choose.\n",
                 color="yellow",
                 file=sys.stderr,
             )
-            if self.config_path_or_template_name.endswith(".yaml"):
+            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:
@@ -267,7 +267,7 @@ class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
             else:
                 prefix = "!" if in_notebook() else ""
                 cprint(
-                    f"Please run:\n\n{prefix}llama stack build --template {self.config_path_or_template_name} --image-type venv\n\n",
+                    f"Please run:\n\n{prefix}llama stack build --distro {self.config_path_or_distro_name} --image-type venv\n\n",
                     "yellow",
                     file=sys.stderr,
                 )
@@ -283,7 +283,7 @@ class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
 
         if not os.environ.get("PYTEST_CURRENT_TEST"):
             console = Console()
-            console.print(f"Using config [blue]{self.config_path_or_template_name}[/blue]:")
+            console.print(f"Using config [blue]{self.config_path_or_distro_name}[/blue]:")
             safe_config = redact_sensitive_fields(self.config.model_dump())
             console.print(yaml.dump(safe_config, indent=2))
 

llama_stack/core/server/server.py

@@ -32,7 +32,7 @@ from openai import BadRequestError
 from pydantic import BaseModel, ValidationError
 
 from llama_stack.apis.common.responses import PaginatedResponse
-from llama_stack.cli.utils import add_config_template_args, get_config_from_args
+from llama_stack.cli.utils import add_config_distro_args, get_config_from_args
 from llama_stack.core.access_control.access_control import AccessDeniedError
 from llama_stack.core.datatypes import (
     AuthenticationRequiredError,
@@ -60,7 +60,7 @@ from llama_stack.core.stack import (
     validate_env_pair,
 )
 from llama_stack.core.utils.config import redact_sensitive_fields
-from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_template
+from llama_stack.core.utils.config_resolution import Mode, resolve_config_or_distro
 from llama_stack.core.utils.context import preserve_contexts_async_generator
 from llama_stack.log import get_logger
 from llama_stack.providers.datatypes import Api
@@ -377,7 +377,7 @@ def main(args: argparse.Namespace | None = None):
     """Start the LlamaStack server."""
     parser = argparse.ArgumentParser(description="Start the LlamaStack server.")
 
-    add_config_template_args(parser)
+    add_config_distro_args(parser)
     parser.add_argument(
         "--port",
         type=int,
@@ -396,8 +396,8 @@ def main(args: argparse.Namespace | None = None):
     if args is None:
         args = parser.parse_args()
 
-    config_or_template = get_config_from_args(args)
-    config_file = resolve_config_or_template(config_or_template, Mode.RUN)
+    config_or_distro = get_config_from_args(args)
+    config_file = resolve_config_or_distro(config_or_distro, Mode.RUN)
 
     logger_config = None
     with open(config_file) as fp:

llama_stack/core/stack.py

@@ -389,12 +389,12 @@ async def refresh_registry_task(impls: dict[Api, Any]):
         await asyncio.sleep(REGISTRY_REFRESH_INTERVAL_SECONDS)
 
 
-def get_stack_run_config_from_template(template: str) -> StackRunConfig:
-    template_path = importlib.resources.files("llama_stack") / f"templates/{template}/run.yaml"
+def get_stack_run_config_from_distro(distro: str) -> StackRunConfig:
+    distro_path = importlib.resources.files("llama_stack") / f"distributions/{distro}/run.yaml"
 
-    with importlib.resources.as_file(template_path) as path:
+    with importlib.resources.as_file(distro_path) as path:
         if not path.exists():
-            raise ValueError(f"Template '{template}' not found at {template_path}")
+            raise ValueError(f"Distribution '{distro}' not found at {distro_path}")
         run_config = yaml.safe_load(path.open())
 
     return StackRunConfig(**replace_env_vars(run_config))

llama_stack/core/ui/README.md

@@ -9,7 +9,7 @@
 1. Start up Llama Stack API server. More details [here](https://llama-stack.readthedocs.io/en/latest/getting_started/index.html).
 
 ```
-llama stack build --template together --image-type venv
+llama stack build --distro together --image-type venv
 
 llama stack run together
 ```

llama_stack/core/utils/config_resolution.py

@@ -13,7 +13,7 @@ from llama_stack.log import get_logger
 logger = get_logger(name=__name__, category="config_resolution")
 
 
-TEMPLATE_DIR = Path(__file__).parent.parent.parent.parent / "llama_stack" / "templates"
+DISTRO_DIR = Path(__file__).parent.parent.parent.parent / "llama_stack" / "distributions"
 
 
 class Mode(StrEnum):
@@ -21,15 +21,15 @@ class Mode(StrEnum):
     BUILD = "build"
 
 
-def resolve_config_or_template(
-    config_or_template: str,
+def resolve_config_or_distro(
+    config_or_distro: str,
     mode: Mode = Mode.RUN,
 ) -> Path:
     """
-    Resolve a config/template argument to a concrete config file path.
+    Resolve a config/distro argument to a concrete config file path.
 
     Args:
-        config_or_template: User input (file path, template name, or built distribution)
+        config_or_distro: User input (file path, distribution name, or built distribution)
         mode: Mode resolving for ("run", "build", "server")
 
     Returns:
@@ -40,86 +40,86 @@ def resolve_config_or_template(
     """
 
     # Strategy 1: Try as file path first
-    config_path = Path(config_or_template)
+    config_path = Path(config_or_distro)
     if config_path.exists() and config_path.is_file():
         logger.info(f"Using file path: {config_path}")
         return config_path.resolve()
 
-    # Strategy 2: Try as template name (if no .yaml extension)
-    if not config_or_template.endswith(".yaml"):
-        template_config = _get_template_config_path(config_or_template, mode)
-        if template_config.exists():
-            logger.info(f"Using template: {template_config}")
-            return template_config
+    # 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)
+        if distro_config.exists():
+            logger.info(f"Using distribution: {distro_config}")
+            return distro_config
 
     # Strategy 3: Try as built distribution name
-    distrib_config = DISTRIBS_BASE_DIR / f"llamastack-{config_or_template}" / f"{config_or_template}-{mode}.yaml"
+    distrib_config = DISTRIBS_BASE_DIR / f"llamastack-{config_or_distro}" / f"{config_or_distro}-{mode}.yaml"
     if distrib_config.exists():
         logger.info(f"Using built distribution: {distrib_config}")
         return distrib_config
 
-    distrib_config = DISTRIBS_BASE_DIR / f"{config_or_template}" / f"{config_or_template}-{mode}.yaml"
+    distrib_config = DISTRIBS_BASE_DIR / f"{config_or_distro}" / f"{config_or_distro}-{mode}.yaml"
     if distrib_config.exists():
         logger.info(f"Using built distribution: {distrib_config}")
         return distrib_config
 
     # Strategy 4: Failed - provide helpful error
-    raise ValueError(_format_resolution_error(config_or_template, mode))
+    raise ValueError(_format_resolution_error(config_or_distro, mode))
 
 
-def _get_template_config_path(template_name: str, mode: Mode) -> Path:
-    """Get the config file path for a template."""
-    return TEMPLATE_DIR / template_name / f"{mode}.yaml"
+def _get_distro_config_path(distro_name: str, mode: Mode) -> Path:
+    """Get the config file path for a distro."""
+    return DISTRO_DIR / distro_name / f"{mode}.yaml"
 
 
-def _format_resolution_error(config_or_template: str, mode: Mode) -> str:
+def _format_resolution_error(config_or_distro: str, mode: Mode) -> str:
     """Format a helpful error message for resolution failures."""
     from llama_stack.core.utils.config_dirs import DISTRIBS_BASE_DIR
 
-    template_path = _get_template_config_path(config_or_template, mode)
-    distrib_path = DISTRIBS_BASE_DIR / f"llamastack-{config_or_template}" / f"{config_or_template}-{mode}.yaml"
-    distrib_path2 = DISTRIBS_BASE_DIR / f"{config_or_template}" / f"{config_or_template}-{mode}.yaml"
+    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"
 
-    available_templates = _get_available_templates()
-    templates_str = ", ".join(available_templates) if available_templates else "none found"
+    available_distros = _get_available_distros()
+    distros_str = ", ".join(available_distros) if available_distros else "none found"
 
-    return f"""Could not resolve config or template '{config_or_template}'.
+    return f"""Could not resolve config or distribution '{config_or_distro}'.
 
 Tried the following locations:
-  1. As file path: {Path(config_or_template).resolve()}
-  2. As template: {template_path}
+  1. As file path: {Path(config_or_distro).resolve()}
+  2. As distribution: {distro_path}
   3. As built distribution: ({distrib_path}, {distrib_path2})
 
-Available templates: {templates_str}
+Available distributions: {distros_str}
 
-Did you mean one of these templates?
-{_format_template_suggestions(available_templates, config_or_template)}
+Did you mean one of these distributions?
+{_format_distro_suggestions(available_distros, config_or_distro)}
 """
 
 
-def _get_available_templates() -> list[str]:
-    """Get list of available template names."""
-    if not TEMPLATE_DIR.exists() and not DISTRIBS_BASE_DIR.exists():
+def _get_available_distros() -> list[str]:
+    """Get list of available distro names."""
+    if not DISTRO_DIR.exists() and not DISTRIBS_BASE_DIR.exists():
         return []
 
     return list(
         set(
-            [d.name for d in TEMPLATE_DIR.iterdir() if d.is_dir() and not d.name.startswith(".")]
+            [d.name for d in DISTRO_DIR.iterdir() if d.is_dir() and not d.name.startswith(".")]
             + [d.name for d in DISTRIBS_BASE_DIR.iterdir() if d.is_dir() and not d.name.startswith(".")]
         )
     )
 
 
-def _format_template_suggestions(templates: list[str], user_input: str) -> str:
-    """Format template suggestions for error messages, showing closest matches first."""
-    if not templates:
-        return "  (no templates found)"
+def _format_distro_suggestions(distros: list[str], user_input: str) -> str:
+    """Format distro suggestions for error messages, showing closest matches first."""
+    if not distros:
+        return "  (no distros found)"
 
     import difflib
 
     # Get up to 3 closest matches with similarity threshold of 0.3 (lower = more permissive)
-    close_matches = difflib.get_close_matches(user_input, templates, n=3, cutoff=0.3)
-    display_templates = close_matches if close_matches else templates[:3]
+    close_matches = difflib.get_close_matches(user_input, distros, n=3, cutoff=0.3)
+    display_distros = close_matches if close_matches else distros[:3]
 
-    suggestions = [f"  - {t}" for t in display_templates]
+    suggestions = [f"  - {d}" for d in display_distros]
     return "\n".join(suggestions)

llama_stack/distributions/ci-tests/ci_tests.py

@@ -5,7 +5,7 @@
 # the root directory of this source tree.
 
 
-from llama_stack.templates.template import DistributionTemplate
+from llama_stack.distributions.template import DistributionTemplate
 
 from ..starter.starter import get_distribution_template as get_starter_distribution_template
 

llama_stack/distributions/dell/dell.py

@@ -12,10 +12,10 @@ from llama_stack.core.datatypes import (
     ShieldInput,
     ToolGroupInput,
 )
+from llama_stack.distributions.template import DistributionTemplate, RunConfigSettings
 from llama_stack.providers.inline.inference.sentence_transformers import (
     SentenceTransformersInferenceConfig,
 )
-from llama_stack.templates.template import DistributionTemplate, RunConfigSettings
 
 
 def get_distribution_template() -> DistributionTemplate:

llama_stack/distributions/dell/doc_template.md

@@ -141,7 +141,7 @@ docker run \
   --pull always \
   -p $LLAMA_STACK_PORT:$LLAMA_STACK_PORT \
   -v $HOME/.llama:/root/.llama \
-  -v ./llama_stack/templates/tgi/run-with-safety.yaml:/root/my-run.yaml \
+  -v ./llama_stack/distributions/tgi/run-with-safety.yaml:/root/my-run.yaml \
   llamastack/distribution-{{ name }} \
   --config /root/my-run.yaml \
   --port $LLAMA_STACK_PORT \
@@ -157,7 +157,7 @@ docker run \
 Make sure you have done `pip install llama-stack` and have the Llama Stack CLI available.
 
 ```bash
-llama stack build --template {{ name }} --image-type conda
+llama stack build --distro {{ name }} --image-type conda
 llama stack run {{ name }}
   --port $LLAMA_STACK_PORT \
   --env INFERENCE_MODEL=$INFERENCE_MODEL \

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

@@ -97,7 +97,7 @@ docker run \
 Make sure you have done `uv pip install llama-stack` and have the Llama Stack CLI available.
 
 ```bash
-llama stack build --template {{ name }} --image-type venv
+llama stack build --distro {{ name }} --image-type venv
 llama stack run distributions/{{ name }}/run.yaml \
   --port 8321 \
   --env INFERENCE_MODEL=meta-llama/Llama-3.2-3B-Instruct

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

@@ -14,6 +14,7 @@ from llama_stack.core.datatypes import (
     ShieldInput,
     ToolGroupInput,
 )
+from llama_stack.distributions.template import DistributionTemplate, RunConfigSettings
 from llama_stack.providers.inline.inference.meta_reference import (
     MetaReferenceInferenceConfig,
 )
@@ -21,7 +22,6 @@ from llama_stack.providers.inline.inference.sentence_transformers import (
     SentenceTransformersInferenceConfig,
 )
 from llama_stack.providers.inline.vector_io.faiss.config import FaissVectorIOConfig
-from llama_stack.templates.template import DistributionTemplate, RunConfigSettings
 
 
 def get_distribution_template() -> DistributionTemplate:

llama_stack/distributions/nvidia/doc_template.md

@@ -130,7 +130,7 @@ If you've set up your local development environment, you can also build the imag
 
 ```bash
 INFERENCE_MODEL=meta-llama/Llama-3.1-8b-Instruct
-llama stack build --template nvidia --image-type venv
+llama stack build --distro nvidia --image-type venv
 llama stack run ./run.yaml \
   --port 8321 \
   --env NVIDIA_API_KEY=$NVIDIA_API_KEY \

llama_stack/distributions/nvidia/nvidia.py

@@ -7,12 +7,12 @@
 from pathlib import Path
 
 from llama_stack.core.datatypes import BuildProvider, ModelInput, Provider, ShieldInput, ToolGroupInput
+from llama_stack.distributions.template import DistributionTemplate, RunConfigSettings, get_model_registry
 from llama_stack.providers.remote.datasetio.nvidia import NvidiaDatasetIOConfig
 from llama_stack.providers.remote.eval.nvidia import NVIDIAEvalConfig
 from llama_stack.providers.remote.inference.nvidia import NVIDIAConfig
 from llama_stack.providers.remote.inference.nvidia.models import MODEL_ENTRIES
 from llama_stack.providers.remote.safety.nvidia import NVIDIASafetyConfig
-from llama_stack.templates.template import DistributionTemplate, RunConfigSettings, get_model_registry
 
 
 def get_distribution_template() -> DistributionTemplate:

llama_stack/distributions/open-benchmark/open_benchmark.py

@@ -16,6 +16,11 @@ from llama_stack.core.datatypes import (
     ShieldInput,
     ToolGroupInput,
 )
+from llama_stack.distributions.template import (
+    DistributionTemplate,
+    RunConfigSettings,
+    get_model_registry,
+)
 from llama_stack.providers.inline.vector_io.sqlite_vec.config import (
     SQLiteVectorIOConfig,
 )
@@ -29,11 +34,6 @@ from llama_stack.providers.remote.vector_io.pgvector.config import (
     PGVectorVectorIOConfig,
 )
 from llama_stack.providers.utils.inference.model_registry import ProviderModelEntry
-from llama_stack.templates.template import (
-    DistributionTemplate,
-    RunConfigSettings,
-    get_model_registry,
-)
 
 
 def get_inference_providers() -> tuple[list[Provider], dict[str, list[ProviderModelEntry]]]:

llama_stack/distributions/postgres-demo/postgres_demo.py

@@ -13,15 +13,15 @@ from llama_stack.core.datatypes import (
     ShieldInput,
     ToolGroupInput,
 )
+from llama_stack.distributions.template import (
+    DistributionTemplate,
+    RunConfigSettings,
+)
 from llama_stack.providers.inline.inference.sentence_transformers import SentenceTransformersInferenceConfig
 from llama_stack.providers.remote.inference.vllm import VLLMInferenceAdapterConfig
 from llama_stack.providers.remote.vector_io.chroma.config import ChromaVectorIOConfig
 from llama_stack.providers.utils.kvstore.config import PostgresKVStoreConfig
 from llama_stack.providers.utils.sqlstore.sqlstore import PostgresSqlStoreConfig
-from llama_stack.templates.template import (
-    DistributionTemplate,
-    RunConfigSettings,
-)
 
 
 def get_distribution_template() -> DistributionTemplate:

llama_stack/distributions/starter/starter.py

@@ -15,6 +15,10 @@ from llama_stack.core.datatypes import (
     ToolGroupInput,
 )
 from llama_stack.core.utils.dynamic import instantiate_class_type
+from llama_stack.distributions.template import (
+    DistributionTemplate,
+    RunConfigSettings,
+)
 from llama_stack.providers.datatypes import RemoteProviderSpec
 from llama_stack.providers.inline.files.localfs.config import LocalfsFilesImplConfig
 from llama_stack.providers.inline.inference.sentence_transformers import (
@@ -33,10 +37,6 @@ from llama_stack.providers.remote.vector_io.pgvector.config import (
     PGVectorVectorIOConfig,
 )
 from llama_stack.providers.utils.sqlstore.sqlstore import PostgresSqlStoreConfig
-from llama_stack.templates.template import (
-    DistributionTemplate,
-    RunConfigSettings,
-)
 
 
 def _get_config_for_provider(provider_spec: ProviderSpec) -> dict[str, Any]:

llama_stack/distributions/watsonx/watsonx.py

@@ -8,12 +8,12 @@ from pathlib import Path
 
 from llama_stack.apis.models import ModelType
 from llama_stack.core.datatypes import BuildProvider, ModelInput, Provider, ToolGroupInput
+from llama_stack.distributions.template import DistributionTemplate, RunConfigSettings, get_model_registry
 from llama_stack.providers.inline.inference.sentence_transformers import (
     SentenceTransformersInferenceConfig,
 )
 from llama_stack.providers.remote.inference.watsonx import WatsonXConfig
 from llama_stack.providers.remote.inference.watsonx.models import MODEL_ENTRIES
-from llama_stack.templates.template import DistributionTemplate, RunConfigSettings, get_model_registry
 
 
 def get_distribution_template() -> DistributionTemplate:

llama_stack/providers/remote/datasetio/nvidia/README.md

@@ -20,7 +20,7 @@ This provider enables dataset management using NVIDIA's NeMo Customizer service.
 Build the NVIDIA environment:
 
 ```bash
-llama stack build --template nvidia --image-type venv
+llama stack build --distro nvidia --image-type venv
 ```
 
 ### Basic Usage using the LlamaStack Python Client

llama_stack/providers/remote/inference/nvidia/NVIDIA.md

@@ -18,7 +18,7 @@ This provider enables running inference using NVIDIA NIM.
 Build the NVIDIA environment:
 
 ```bash
-llama stack build --template nvidia --image-type venv
+llama stack build --distro nvidia --image-type venv
 ```
 
 ### Basic Usage using the LlamaStack Python Client

llama_stack/providers/remote/post_training/nvidia/README.md

@@ -22,7 +22,7 @@ This provider enables fine-tuning of LLMs using NVIDIA's NeMo Customizer service
 Build the NVIDIA environment:
 
 ```bash
-llama stack build --template nvidia --image-type venv
+llama stack build --distro nvidia --image-type venv
 ```
 
 ### Basic Usage using the LlamaStack Python Client

llama_stack/providers/remote/safety/nvidia/README.md

@@ -19,7 +19,7 @@ This provider enables safety checks and guardrails for LLM interactions using NV
 Build the NVIDIA environment:
 
 ```bash
-llama stack build --template nvidia --image-type venv
+llama stack build --distro nvidia --image-type venv
 ```
 
 ### Basic Usage using the LlamaStack Python Client