tenseleyflow/documentlanguagemodel / e9dda81

+work is landing incrementally. Current export targets are `ollama`,

+`llama-server`, and `vllm`.

+| `--target NAME` | `ollama` | Export destination. Sprint 41 currently supports `ollama`, `llama-server`, and `vllm`. The `llama-server` path writes launch artifacts against the existing GGUF export and uses the shared OpenAI-compatible HTTP smoke harness; the `vllm` path writes `vllm_launch.sh` + `vllm_config.json` against the local adapter layout and ignores GGUF-only flags. |

+            help="Export destination. Currently supported: ollama, llama-server, vllm.",

+    from dlm.export.targets import (

+        finalize_vllm_export,

+        prepare_llama_server_export,

+        prepare_vllm_export,

+        resolve_target,

+    )

+    if resolved_target.name == "vllm" and export_dispatch.accepts_audio:

+        console.print(

+            "[red]export:[/red] --target vllm is not wired for audio-language "

+            "documents yet; this Sprint 41 slice only supports text bases."

+        )

+        raise typer.Exit(code=2)

+    if resolved_target.name == "vllm" and export_dispatch.accepts_images:

+        console.print(

+            "[red]export:[/red] --target vllm is not wired for vision-language "

+            "documents yet; this Sprint 41 slice only supports text bases."

+        )

+        raise typer.Exit(code=2)

+    if resolved_target.name == "vllm":

+        ignored_flags: list[str] = []

+        if quant is not None:

+            ignored_flags.append("--quant")

+        if merged:

+            ignored_flags.append("--merged")

+        if dequantize:

+            ignored_flags.append("--dequantize")

+        if no_template:

+            ignored_flags.append("--no-template")

+        if skip_ollama:

+            ignored_flags.append("--skip-ollama")

+        if no_imatrix:

+            ignored_flags.append("--no-imatrix")

+        if draft is not None:

+            ignored_flags.append("--draft")

+        if no_draft:

+            ignored_flags.append("--no-draft")

+        if ignored_flags:

+            console.print(

+                "[yellow]export:[/yellow] ignoring flags not applicable to "

+                f"`--target vllm`: {', '.join(ignored_flags)}"

+            )

+

+        declared_adapter_names = tuple(adapters_declared.keys()) if adapters_declared else None

+        try:

+            vllm_result = prepare_vllm_export(

+                store=store,

+                spec=spec,

+                served_model_name=name or f"dlm-{parsed.frontmatter.dlm_id.lower()}",

+                adapter_name=adapter,

+                adapter_path_override=adapter_path_override,

+                declared_adapter_names=declared_adapter_names,

+            )

+        except ExportError as exc:

+            console.print(f"[red]export:[/red] {exc}")

+            raise typer.Exit(code=1) from exc

+

+        vllm_smoke = None if no_smoke else resolved_target.smoke_test(vllm_result)

+        if vllm_smoke is not None and not vllm_smoke.ok:

+            console.print(

+                f"[red]smoke:[/red] {vllm_smoke.detail}\n"

+                "  re-run with `--no-smoke` to skip the smoke test."

+            )

+            raise typer.Exit(code=1)

+

+        manifest_path = finalize_vllm_export(

+            store=store,

+            spec=spec,

+            prepared=vllm_result,

+            smoke_output_first_line=None if vllm_smoke is None else vllm_smoke.detail,

+            adapter_name=adapter,

+            adapter_mix=mix_entries,

+        )

+        console.print(f"[green]exported:[/green] {vllm_result.export_dir}")

+        console.print("target:  vllm")

+        assert vllm_result.launch_script_path is not None

+        assert vllm_result.config_path is not None

+        console.print(f"launch:  {vllm_result.launch_script_path.name}")

+        console.print(f"config:  {vllm_result.config_path.name}")

+        console.print(f"manifest: {manifest_path.name}")

+        if vllm_smoke is not None and vllm_smoke.detail:

+            console.print(f"smoke:   {vllm_smoke.detail}")

+        return

+

+"""Shared export-record helpers used by GGUF and non-GGUF targets."""

+

+from __future__ import annotations

+

+from typing import TYPE_CHECKING, Any

+

+from dlm.export.manifest import utc_now

+

+if TYPE_CHECKING:

+    from dlm.store.paths import StorePath

+

+

+def append_export_summary(

+    *,

+    store: StorePath,

+    quant: str,

+    merged: bool,

+    target: str,

+    llama_cpp_tag: str | None,

+    artifacts: list[Any],

+    ollama_name: str | None,

+    ollama_version_str: str | None,

+    smoke_first_line: str | None,

+    adapter_name: str | None = None,

+    adapter_mix: list[tuple[str, float]] | None = None,

+    timeout: float = 60.0,

+) -> None:

+    """Update `manifest.exports` with one new export row."""

+    from dlm.store.lock import exclusive

+    from dlm.store.manifest import ExportSummary, load_manifest, save_manifest

+

+    base_sha = next((a.sha256 for a in artifacts if a.path.startswith("base.")), None)

+    adapter_sha = next((a.sha256 for a in artifacts if a.path.startswith("adapter.")), None)

+

+    summary = ExportSummary(

+        exported_at=utc_now(),

+        target=target,

+        quant=quant,

+        merged=merged,

+        ollama_name=ollama_name,

+        ollama_version=ollama_version_str,

+        llama_cpp_tag=llama_cpp_tag,

+        base_gguf_sha256=base_sha,

+        adapter_gguf_sha256=adapter_sha,

+        smoke_output_first_line=smoke_first_line,

+        adapter_name=adapter_name,

+        adapter_mix=adapter_mix,

+    )

+

+    with exclusive(store.lock, timeout=timeout):

+        manifest = load_manifest(store.manifest)

+        updated = manifest.model_copy(

+            update={

+                "exports": [*manifest.exports, summary],

+                "updated_at": utc_now(),

+            }

+        )

+        save_manifest(store.manifest, updated)

+from dlm.export.record import append_export_summary

+    append_export_summary(

+        quant=plan.quant,

+        merged=plan.merged,

+        timeout=_APPEND_LOCK_TIMEOUT,

+from dlm.export.targets.vllm import VLLM_TARGET, finalize_vllm_export, prepare_vllm_export

+    VLLM_TARGET.name: VLLM_TARGET,

+    "VLLM_TARGET",

+    "finalize_vllm_export",

+    "prepare_vllm_export",

+"""vLLM target helpers."""

+

+from __future__ import annotations

+

+import json

+import shlex

+import shutil

+from dataclasses import dataclass

+from pathlib import Path

+

+from dlm.base_models import BaseModelSpec

+from dlm.export.errors import ExportError, TargetSmokeError

+from dlm.export.manifest import ExportManifest, build_artifact, save_export_manifest, utc_now

+from dlm.export.record import append_export_summary

+from dlm.export.smoke import smoke_openai_compat_server

+from dlm.export.targets.base import ExportTarget, SmokeResult, TargetResult

+from dlm.io.atomic import write_text

+from dlm.store.paths import StorePath

+

+VLLM_EXPORT_SUBDIR = "vllm"

+VLLM_CONFIG_FILENAME = "vllm_config.json"

+LAUNCH_SCRIPT_FILENAME = "vllm_launch.sh"

+_ADAPTERS_DIRNAME = "adapters"

+_HF_QUANT = "hf"

+_DEFAULT_MODULE_NAME = "adapter"

+_MIXED_MODULE_NAME = "mixed"

+

+

+@dataclass(frozen=True)

+class LoraModule:

+    name: str

+    path: Path

+    adapter_version: int

+

+

+class VllmTarget:

+    """Registered export target for vLLM launch artifacts."""

+

+    name = "vllm"

+

+    def prepare(self, ctx: object) -> TargetResult:

+        raise NotImplementedError("vllm exports are prepared via prepare_vllm_export()")

+

+    def launch_command(self, prepared: TargetResult) -> list[str]:

+        return _build_command(prepared, use_script_dir=True)

+

+    def smoke_test(self, prepared: TargetResult) -> SmokeResult:

+        try:

+            first_line = smoke_openai_compat_server(_build_command(prepared, use_script_dir=False))

+        except (OSError, TargetSmokeError, ExportError) as exc:

+            return SmokeResult(attempted=True, ok=False, detail=str(exc))

+        return SmokeResult(attempted=True, ok=True, detail=first_line)

+

+

+def prepare_vllm_export(

+    *,

+    store: StorePath,

+    spec: BaseModelSpec,

+    served_model_name: str,

+    adapter_name: str | None,

+    adapter_path_override: Path | None,

+    declared_adapter_names: tuple[str, ...] | None,

+) -> TargetResult:

+    """Stage vLLM launch artifacts plus local adapter module copies."""

+

+    export_dir = store.exports / VLLM_EXPORT_SUBDIR

+    export_dir.mkdir(parents=True, exist_ok=True)

+

+    adapters_dir = export_dir / _ADAPTERS_DIRNAME

+    if adapters_dir.exists():

+        shutil.rmtree(adapters_dir)

+    adapters_dir.mkdir(parents=True, exist_ok=True)

+

+    modules = _stage_modules(

+        store=store,

+        adapters_dir=adapters_dir,

+        adapter_name=adapter_name,

+        adapter_path_override=adapter_path_override,

+        declared_adapter_names=declared_adapter_names,

+    )

+    if not modules:

+        raise ExportError("vllm export needs at least one adapter module")

+

+    config_path = export_dir / VLLM_CONFIG_FILENAME

+    launch_script_path = export_dir / LAUNCH_SCRIPT_FILENAME

+    draft = TargetResult(

+        name=VLLM_TARGET.name,

+        export_dir=export_dir,

+        manifest_path=export_dir / "export_manifest.json",

+        artifacts=(),

+        launch_script_path=launch_script_path,

+        config_path=config_path,

+        extras={

+            "model": spec.hf_id,

+            "revision": spec.revision,

+            "served_model_name": served_model_name,

+            "module_specs": tuple(modules),

+            "adapter_version": max(module.adapter_version for module in modules),

+        },

+    )

+    write_text(config_path, _render_config(draft))

+    write_text(launch_script_path, _render_launch_script(VLLM_TARGET.launch_command(draft)))

+    launch_script_path.chmod(0o755)

+    return TargetResult(

+        name=draft.name,

+        export_dir=draft.export_dir,

+        manifest_path=draft.manifest_path,

+        artifacts=tuple(_artifact_paths(export_dir)),

+        launch_script_path=draft.launch_script_path,

+        config_path=draft.config_path,

+        extras=draft.extras,

+    )

+

+

+def finalize_vllm_export(

+    *,

+    store: StorePath,

+    spec: BaseModelSpec,

+    prepared: TargetResult,

+    smoke_output_first_line: str | None,

+    adapter_name: str | None,

+    adapter_mix: list[tuple[str, float]] | None,

+) -> Path:

+    """Write export_manifest.json and append the store export summary."""

+

+    from dlm import __version__ as dlm_version

+

+    artifacts = [

+        build_artifact(prepared.export_dir, path) for path in _artifact_paths(prepared.export_dir)

+    ]

+    adapter_version = _require_prepared_int(prepared, "adapter_version")

+    manifest = ExportManifest(

+        target=VLLM_TARGET.name,

+        quant=_HF_QUANT,

+        merged=False,

+        dequantized=False,

+        ollama_name=None,

+        created_at=utc_now(),

+        created_by=f"dlm-{dlm_version}",

+        llama_cpp_tag=None,

+        base_model_hf_id=spec.hf_id,

+        base_model_revision=spec.revision,

+        adapter_version=adapter_version,

+        artifacts=artifacts,

+    )

+    manifest_path = save_export_manifest(prepared.export_dir, manifest)

+    append_export_summary(

+        store=store,

+        quant=_HF_QUANT,

+        merged=False,

+        target=VLLM_TARGET.name,

+        llama_cpp_tag=None,

+        artifacts=artifacts,

+        ollama_name=None,

+        ollama_version_str=None,

+        smoke_first_line=smoke_output_first_line,

+        adapter_name=adapter_name,

+        adapter_mix=adapter_mix,

+    )

+    return manifest_path

+

+

+def _stage_modules(

+    *,

+    store: StorePath,

+    adapters_dir: Path,

+    adapter_name: str | None,

+    adapter_path_override: Path | None,

+    declared_adapter_names: tuple[str, ...] | None,

+) -> list[LoraModule]:

+    modules = _resolve_modules(

+        store=store,

+        adapter_name=adapter_name,

+        adapter_path_override=adapter_path_override,

+        declared_adapter_names=declared_adapter_names,

+    )

+    staged: list[LoraModule] = []

+    for module in modules:

+        target_dir = adapters_dir / module.name

+        shutil.copytree(module.path, target_dir)

+        staged.append(LoraModule(module.name, target_dir, module.adapter_version))

+    return staged

+

+

+def _resolve_modules(

+    *,

+    store: StorePath,

+    adapter_name: str | None,

+    adapter_path_override: Path | None,

+    declared_adapter_names: tuple[str, ...] | None,

+) -> list[LoraModule]:

+    if adapter_path_override is not None:

+        if not adapter_path_override.exists():

+            raise ExportError(f"adapter_path_override {adapter_path_override} does not exist")

+        return [

+            LoraModule(

+                name=_MIXED_MODULE_NAME,

+                path=adapter_path_override,

+                adapter_version=_version_from_dir_name(adapter_path_override),

+            )

+        ]

+

+    if adapter_name is not None:

+        path = store.resolve_current_adapter_for(adapter_name)

+        pointer = store.adapter_current_pointer_for(adapter_name)

+        if path is None or not path.exists():

+            raise ExportError(

+                f"no current adapter under {pointer}; run `dlm train` before exporting."

+            )

+        return [

+            LoraModule(

+                name=adapter_name,

+                path=path,

+                adapter_version=_version_from_dir_name(path),

+            )

+        ]

+

+    if declared_adapter_names:

+        modules: list[LoraModule] = []

+        for name in declared_adapter_names:

+            path = store.resolve_current_adapter_for(name)

+            pointer = store.adapter_current_pointer_for(name)

+            if path is None or not path.exists():

+                raise ExportError(

+                    f"no current adapter under {pointer}; run `dlm train` before exporting."

+                )

+            modules.append(

+                LoraModule(name=name, path=path, adapter_version=_version_from_dir_name(path))

+            )

+        return modules

+

+    path = store.resolve_current_adapter()

+    pointer = store.adapter_current_pointer

+    if path is None or not path.exists():

+        raise ExportError(f"no current adapter under {pointer}; run `dlm train` before exporting.")

+    return [

+        LoraModule(

+            name=_DEFAULT_MODULE_NAME,

+            path=path,

+            adapter_version=_version_from_dir_name(path),

+        )

+    ]

+

+

+def _version_from_dir_name(path: Path) -> int:

+    stem = path.name

+    if not stem.startswith("v") or not stem[1:].isdigit():

+        return 1

+    return int(stem[1:])

+

+

+def _artifact_paths(export_dir: Path) -> list[Path]:

+    artifacts: list[Path] = []

+    for path in sorted(export_dir.rglob("*")):

+        if path.is_file() and path.name != "export_manifest.json":

+            artifacts.append(path)

+    return artifacts

+

+

+def _build_command(prepared: TargetResult, *, use_script_dir: bool) -> list[str]:

+    model = _require_prepared_str(prepared, "model")

+    revision = _require_prepared_str(prepared, "revision")

+    served_model_name = _require_prepared_str(prepared, "served_model_name")

+    modules = _require_module_specs(prepared)

+

+    command = [

+        "vllm",

+        "serve",

+        model,

+        "--revision",

+        revision,

+        "--host",

+        "127.0.0.1",

+        "--port",

+        "8000",

+        "--dtype",

+        "auto",

+        "--served-model-name",

+        served_model_name,

+    ]

+    if modules:

+        command.extend(["--enable-lora", "--lora-modules"])

+        for module in modules:

+            path = (

+                f"$SCRIPT_DIR/{_ADAPTERS_DIRNAME}/{module.name}"

+                if use_script_dir

+                else str(module.path)

+            )

+            command.append(f"{module.name}={path}")

+    return command

+

+

+def _render_config(prepared: TargetResult) -> str:

+    modules = _require_module_specs(prepared)

+    payload = {

+        "target": VLLM_TARGET.name,

+        "model": _require_prepared_str(prepared, "model"),

+        "revision": _require_prepared_str(prepared, "revision"),

+        "served_model_name": _require_prepared_str(prepared, "served_model_name"),

+        "dtype": "auto",

+        "host": "127.0.0.1",

+        "port": 8000,

+        "lora_modules": [

+            {

+                "name": module.name,

+                "path": f"{_ADAPTERS_DIRNAME}/{module.name}",

+                "adapter_version": module.adapter_version,

+            }

+            for module in modules

+        ],

+    }

+    return json.dumps(payload, sort_keys=True, indent=2) + "\n"

+

+

+def _render_launch_script(command: list[str]) -> str:

+    rendered = " ".join(_quote_script_arg(arg) for arg in command)

+    return (

+        "#!/usr/bin/env bash\n"

+        "set -euo pipefail\n"

+        'SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"\n'

+        f'exec {rendered} "$@"\n'

+    )

+

+

+def _quote_script_arg(arg: str) -> str:

+    if arg.startswith("$SCRIPT_DIR/"):

+        return f'"{arg}"'

+    if "=$SCRIPT_DIR/" in arg:

+        name, value = arg.split("=", 1)

+        return f'{shlex.quote(name)}="{value}"'

+    return shlex.quote(arg)

+

+

+def _require_prepared_str(prepared: TargetResult, key: str) -> str:

+    value = prepared.extras.get(key)

+    if not isinstance(value, str) or not value:

+        raise ExportError(f"vllm prepared target missing string extra {key!r}")

+    return value

+

+

+def _require_prepared_int(prepared: TargetResult, key: str) -> int:

+    value = prepared.extras.get(key)

+    if not isinstance(value, int):

+        raise ExportError(f"vllm prepared target missing int extra {key!r}")

+    return value

+

+

+def _require_module_specs(prepared: TargetResult) -> tuple[LoraModule, ...]:

+    value = prepared.extras.get("module_specs")

+    if not isinstance(value, tuple) or not all(isinstance(item, LoraModule) for item in value):

+        raise ExportError("vllm prepared target missing LoraModule tuple extra 'module_specs'")

+    return value

+

+

+VLLM_TARGET = VllmTarget()

+assert isinstance(VLLM_TARGET, ExportTarget)

+                "sglang",

+        assert "vllm" in text

+

+    def test_vllm_target_reaches_existing_mutex_validation(self, tmp_path: Path) -> None:

+        runner = CliRunner()

+        result = runner.invoke(

+            app,

+            [

+                "--home",

+                str(tmp_path / "home"),

+                "export",

+                str(tmp_path / "ghost.dlm"),

+                "--target",

+                "vllm",

+                "--draft",

+                "qwen2.5:0.5b",

+                "--no-draft",

+            ],

+        )

+        assert result.exit_code == 2

+        assert "mutually exclusive" in _joined(result)

+    def test_targets_are_registered(self) -> None:

+        assert "vllm" in TARGETS

+        assert available_targets() == ("ollama", "llama-server", "vllm")

+            match="available targets: ollama, llama-server, vllm",

+            resolve_target("sglang")

+"""vLLM launch artifact generation."""

+

+from __future__ import annotations

+

+import json

+from pathlib import Path

+

+from dlm.base_models import BASE_MODELS

+from dlm.export.manifest import load_export_manifest

+from dlm.export.targets.vllm import (

+    VLLM_CONFIG_FILENAME,

+    VLLM_TARGET,

+    finalize_vllm_export,

+    prepare_vllm_export,

+)

+from dlm.store.manifest import Manifest, load_manifest, save_manifest

+from dlm.store.paths import for_dlm

+

+_SPEC = BASE_MODELS["smollm2-135m"]

+

+

+def _write_adapter(path: Path) -> None:

+    path.mkdir(parents=True)

+    (path / "adapter_config.json").write_text("{}", encoding="utf-8")

+    (path / "adapter_model.safetensors").write_bytes(b"adapter")

+    (path / "tokenizer_config.json").write_text(

+        json.dumps({"chat_template": "{{messages}}", "vocab_size": 32000}),

+        encoding="utf-8",

+    )

+

+

+def _setup_flat_store(tmp_path: Path) -> object:

+    store = for_dlm("01VLLMTEST", home=tmp_path)

+    store.ensure_layout()

+    save_manifest(store.manifest, Manifest(dlm_id="01VLLMTEST", base_model=_SPEC.key))

+    adapter = store.adapter_version(3)

+    _write_adapter(adapter)

+    store.set_current_adapter(adapter)

+    return store

+

+

+def _setup_named_store(tmp_path: Path) -> object:

+    store = for_dlm("01VLLMMULTI", home=tmp_path)

+    store.ensure_layout()

+    save_manifest(store.manifest, Manifest(dlm_id="01VLLMMULTI", base_model=_SPEC.key))

+    knowledge = store.adapter_version_for("knowledge", 2)

+    tone = store.adapter_version_for("tone", 4)

+    _write_adapter(knowledge)

+    _write_adapter(tone)

+    store.set_current_adapter_for("knowledge", knowledge)

+    store.set_current_adapter_for("tone", tone)

+    return store

+

+

+class TestPrepareVllmExport:

+    def test_flat_export_writes_config_manifest_and_launch_script(self, tmp_path: Path) -> None:

+        store = _setup_flat_store(tmp_path)

+

+        prepared = prepare_vllm_export(

+            store=store,

+            spec=_SPEC,

+            served_model_name="dlm-flat",

+            adapter_name=None,

+            adapter_path_override=None,

+            declared_adapter_names=None,

+        )

+        manifest_path = finalize_vllm_export(

+            store=store,

+            spec=_SPEC,

+            prepared=prepared,

+            smoke_output_first_line="hello from vllm",

+            adapter_name=None,

+            adapter_mix=None,

+        )

+

+        assert prepared.launch_script_path is not None

+        script = prepared.launch_script_path.read_text(encoding="utf-8")

+        assert script.startswith("#!/usr/bin/env bash\nset -euo pipefail\n")

+        assert "vllm serve" in script

+        assert _SPEC.hf_id in script

+        assert "--revision" in script

+        assert "--served-model-name dlm-flat" in script

+        assert 'adapter="$SCRIPT_DIR/adapters/adapter"' in script

+

+        config = json.loads(

+            (prepared.export_dir / VLLM_CONFIG_FILENAME).read_text(encoding="utf-8")

+        )

+        assert config["target"] == "vllm"

+        assert config["model"] == _SPEC.hf_id

+        assert config["served_model_name"] == "dlm-flat"

+        assert config["lora_modules"] == [

+            {"adapter_version": 3, "name": "adapter", "path": "adapters/adapter"}

+        ]

+

+        export_manifest = load_export_manifest(prepared.export_dir)

+        assert manifest_path == prepared.manifest_path

+        assert export_manifest.target == "vllm"

+        assert export_manifest.quant == "hf"

+        assert export_manifest.adapter_version == 3

+        assert any(artifact.path == "vllm_launch.sh" for artifact in export_manifest.artifacts)

+        assert any(artifact.path == "vllm_config.json" for artifact in export_manifest.artifacts)

+        assert any(

+            artifact.path == "adapters/adapter/adapter_model.safetensors"

+            for artifact in export_manifest.artifacts

+        )

+

+        store_manifest = load_manifest(store.manifest)

+        assert store_manifest.exports[-1].target == "vllm"

+        assert store_manifest.exports[-1].quant == "hf"

+        assert store_manifest.exports[-1].smoke_output_first_line == "hello from vllm"

+

+    def test_multi_adapter_export_includes_all_named_modules(self, tmp_path: Path) -> None:

+        store = _setup_named_store(tmp_path)

+

+        prepared = prepare_vllm_export(

+            store=store,

+            spec=_SPEC,

+            served_model_name="dlm-multi",

+            adapter_name=None,

+            adapter_path_override=None,

+            declared_adapter_names=("knowledge", "tone"),

+        )

+

+        script = prepared.launch_script_path.read_text(encoding="utf-8")

+        assert 'knowledge="$SCRIPT_DIR/adapters/knowledge"' in script

+        assert 'tone="$SCRIPT_DIR/adapters/tone"' in script

+

+        config = json.loads(

+            (prepared.export_dir / VLLM_CONFIG_FILENAME).read_text(encoding="utf-8")

+        )

+        assert config["lora_modules"] == [

+            {"adapter_version": 2, "name": "knowledge", "path": "adapters/knowledge"},

+            {"adapter_version": 4, "name": "tone", "path": "adapters/tone"},

+        ]

+

+

+class TestVllmSmoke:

+    def test_smoke_uses_absolute_runtime_paths(self, tmp_path: Path, monkeypatch: object) -> None:

+        store = _setup_named_store(tmp_path)

+        prepared = prepare_vllm_export(

+            store=store,

+            spec=_SPEC,

+            served_model_name="dlm-multi",

+            adapter_name=None,

+            adapter_path_override=None,

+            declared_adapter_names=("knowledge", "tone"),

+        )

+        seen: list[list[str]] = []

+

+        def _fake_smoke(argv: list[str], **_: object) -> str:

+            seen.append(list(argv))

+            return "vllm replied"

+

+        monkeypatch.setattr("dlm.export.targets.vllm.smoke_openai_compat_server", _fake_smoke)

+

+        result = VLLM_TARGET.smoke_test(prepared)

+

+        assert result.attempted is True

+        assert result.ok is True

+        assert result.detail == "vllm replied"

+        argv = seen[0]

+        assert argv[:2] == ["vllm", "serve"]

+        assert "$SCRIPT_DIR" not in " ".join(argv)

+        assert _SPEC.hf_id in argv

+        assert f"knowledge={prepared.export_dir / 'adapters' / 'knowledge'}" in argv

+        assert f"tone={prepared.export_dir / 'adapters' / 'tone'}" in argv