`19042db`

Stabilize export smoke coverage

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 weeks ago

SHA: 19042dba2924653d552fc2b0ac4db75e7991a65d
Parents: 1c7561e
Tree: 7d3212c

4 changed files

Status	File	+	-
M	`tests/unit/export/targets/test_mlx_serve_argv.py`	92	1
M	`tests/unit/export/targets/test_vllm_argv.py`	218	0
A	`tests/unit/export/test_dispatch.py`	340	0
M	`tests/unit/export/test_smoke.py`	354	118

tests/unit/export/targets/test_mlx_serve_argv.pymodified

  import pytest
  from dlm.base_models import BASE_MODELS
 -from dlm.export.errors import ExportError
 +from dlm.export.errors import ExportError, TargetSmokeError
  from dlm.export.manifest import load_export_manifest
 +from dlm.export.targets.base import TargetResult
  from dlm.export.targets.mlx_serve import (
      LAUNCH_SCRIPT_FILENAME,
      MLX_SERVE_TARGET,
 +    _quote_script_arg,
 +    _require_prepared_int,
      finalize_mlx_serve_export,
      prepare_mlx_serve_export,
+ )
  class TestPrepareMlxServeExport:
 +    def test_prepare_method_is_not_used_directly(self) -> None:
 +        with pytest.raises(NotImplementedError, match="prepare_mlx_serve_export"):
 +            MLX_SERVE_TARGET.prepare(object())
++
      def test_prepare_writes_launch_script_and_manifest(
          self, tmp_path: Path, monkeypatch: object
      ) -> None:
                  declared_adapter_names=None,
+             )
 +    def test_refuses_without_mlx_extra(self, tmp_path: Path, monkeypatch: object) -> None:
 +        store = _setup_flat_store(tmp_path)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.is_apple_silicon", lambda: True)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.mlx_available", lambda: False)
++
 +        with pytest.raises(ExportError, match="mlx extra"):
 +            prepare_mlx_serve_export(
 +                store=store,
 +                spec=_SPEC,
 +                adapter_name=None,
 +                adapter_path_override=None,
 +                declared_adapter_names=None,
 +            )
++
 +    def test_missing_named_adapter_raises(self, tmp_path: Path, monkeypatch: object) -> None:
 +        store = _setup_named_store(tmp_path)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.is_apple_silicon", lambda: True)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.mlx_available", lambda: True)
++
 +        with pytest.raises(ExportError, match="no current adapter under"):
 +            prepare_mlx_serve_export(
 +                store=store,
 +                spec=_SPEC,
 +                adapter_name="missing",
 +                adapter_path_override=None,
 +                declared_adapter_names=None,
 +            )
++
 +    def test_missing_default_adapter_raises(self, tmp_path: Path, monkeypatch: object) -> None:
 +        store = for_dlm("01EMPTYMLX", home=tmp_path)
 +        store.ensure_layout()
 +        save_manifest(store.manifest, Manifest(dlm_id="01EMPTYMLX", base_model=_SPEC.key))
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.is_apple_silicon", lambda: True)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.mlx_available", lambda: True)
++
 +        with pytest.raises(ExportError, match="no current adapter under"):
 +            prepare_mlx_serve_export(
 +                store=store,
 +                spec=_SPEC,
 +                adapter_name=None,
 +                adapter_path_override=None,
 +                declared_adapter_names=None,
 +            )
++
  class TestMlxServeSmoke:
      def test_smoke_uses_absolute_runtime_paths(self, tmp_path: Path, monkeypatch: object) -> None:
          assert "$SCRIPT_DIR" not in " ".join(argv)
          assert _SPEC.hf_id in argv
          assert str(prepared.export_dir / "adapter") in argv
++
 +    def test_smoke_failure_returns_failed_result(self, tmp_path: Path, monkeypatch: object) -> None:
 +        store = _setup_flat_store(tmp_path)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.is_apple_silicon", lambda: True)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.mlx_available", lambda: True)
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.stage_mlx_adapter_dir", _fake_stage_mlx)
 +        prepared = prepare_mlx_serve_export(
 +            store=store,
 +            spec=_SPEC,
 +            adapter_name=None,
 +            adapter_path_override=None,
 +            declared_adapter_names=None,
 +        )
++
 +        def _fake_smoke(argv: list[str], **_: object) -> str:
 +            _ = argv
 +            raise TargetSmokeError("boom")
++
 +        monkeypatch.setattr("dlm.export.targets.mlx_serve.smoke_openai_compat_server", _fake_smoke)
++
 +        result = MLX_SERVE_TARGET.smoke_test(prepared)
++
 +        assert result.attempted is True
 +        assert result.ok is False
 +        assert result.detail == "boom"
++
++
 +class TestMlxServeHelpers:
 +    def test_quote_script_arg_and_int_validation(self) -> None:
 +        assert _quote_script_arg("$SCRIPT_DIR/adapter") == '"$SCRIPT_DIR/adapter"'
 +        assert _quote_script_arg("plain value") == "'plain value'"
++
 +        prepared = TargetResult(
 +            name="mlx-serve",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"adapter_version": "bad"},
 +        )
 +        with pytest.raises(ExportError, match="missing int extra"):
 +            _require_prepared_int(prepared, "adapter_version")

tests/unit/export/targets/test_vllm_argv.pymodified

  import json
  from pathlib import Path
 +import pytest
++
  from dlm.base_models import BASE_MODELS
 +from dlm.export.errors import ExportError, TargetSmokeError
  from dlm.export.manifest import load_export_manifest
 +from dlm.export.targets.base import TargetResult
  from dlm.export.targets.vllm import (
      VLLM_CONFIG_FILENAME,
      VLLM_TARGET,
 +    LoraModule,
 +    _default_runtime_env,
 +    _optional_prepared_int,
 +    _render_launch_script,
 +    _require_module_specs,
 +    _require_prepared_int,
 +    _require_prepared_str,
 +    _runtime_env,
      finalize_vllm_export,
      prepare_vllm_export,
+ )
  class TestPrepareVllmExport:
 +    def test_prepare_method_is_not_used_directly(self) -> None:
 +        with pytest.raises(NotImplementedError, match="prepare_vllm_export"):
 +            VLLM_TARGET.prepare(object())
++
      def test_flat_export_writes_config_manifest_and_launch_script(self, tmp_path: Path) -> None:
          store = _setup_flat_store(tmp_path)
              "VLLM_METAL_USE_PAGED_ATTENTION": "0",
+         }
 +    def test_prepare_requires_at_least_one_module(
 +        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        store = _setup_flat_store(tmp_path)
 +        monkeypatch.setattr("dlm.export.targets.vllm._stage_modules", lambda **kwargs: [])
++
 +        with pytest.raises(ExportError, match="at least one adapter module"):
 +            prepare_vllm_export(
 +                store=store,
 +                spec=_SPEC,
 +                served_model_name="dlm-flat",
 +                training_sequence_len=2048,
 +                adapter_name=None,
 +                adapter_path_override=None,
 +                declared_adapter_names=None,
 +            )
++
 +    def test_missing_named_adapter_raises(self, tmp_path: Path) -> None:
 +        store = _setup_named_store(tmp_path)
++
 +        with pytest.raises(ExportError, match="no current adapter under"):
 +            prepare_vllm_export(
 +                store=store,
 +                spec=_SPEC,
 +                served_model_name="dlm-missing",
 +                training_sequence_len=2048,
 +                adapter_name="missing",
 +                adapter_path_override=None,
 +                declared_adapter_names=None,
 +            )
++
 +    def test_missing_default_adapter_raises(self, tmp_path: Path) -> None:
 +        store = for_dlm("01EMPTYVLLM", home=tmp_path)
 +        store.ensure_layout()
 +        save_manifest(store.manifest, Manifest(dlm_id="01EMPTYVLLM", base_model=_SPEC.key))
++
 +        with pytest.raises(ExportError, match="no current adapter under"):
 +            prepare_vllm_export(
 +                store=store,
 +                spec=_SPEC,
 +                served_model_name="dlm-empty",
 +                training_sequence_len=2048,
 +                adapter_name=None,
 +                adapter_path_override=None,
 +                declared_adapter_names=None,
 +            )
++
 +    def test_missing_declared_named_adapter_raises(self, tmp_path: Path) -> None:
 +        store = _setup_named_store(tmp_path)
++
 +        with pytest.raises(ExportError, match="no current adapter under"):
 +            prepare_vllm_export(
 +                store=store,
 +                spec=_SPEC,
 +                served_model_name="dlm-multi",
 +                training_sequence_len=2048,
 +                adapter_name=None,
 +                adapter_path_override=None,
 +                declared_adapter_names=("knowledge", "missing"),
 +            )
++
 +    def test_missing_adapter_override_raises(self, tmp_path: Path) -> None:
 +        store = _setup_flat_store(tmp_path)
++
 +        with pytest.raises(ExportError, match="adapter_path_override"):
 +            prepare_vllm_export(
 +                store=store,
 +                spec=_SPEC,
 +                served_model_name="dlm-mixed",
 +                training_sequence_len=2048,
 +                adapter_name=None,
 +                adapter_path_override=tmp_path / "missing",
 +                declared_adapter_names=None,
 +            )
++
  class TestVllmSmoke:
      def test_smoke_uses_absolute_runtime_paths(self, tmp_path: Path, monkeypatch: object) -> None:
+         }
          assert f"knowledge={prepared.export_dir / 'adapters' / 'knowledge'}" in argv
          assert f"tone={prepared.export_dir / 'adapters' / 'tone'}" in argv
++
 +    def test_smoke_failure_returns_failed_result(
 +        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        store = _setup_flat_store(tmp_path)
 +        prepared = prepare_vllm_export(
 +            store=store,
 +            spec=_SPEC,
 +            served_model_name="dlm-flat",
 +            training_sequence_len=2048,
 +            adapter_name=None,
 +            adapter_path_override=None,
 +            declared_adapter_names=None,
 +        )
 +        monkeypatch.setattr(
 +            "dlm.export.targets.vllm.smoke_openai_compat_server",
 +            lambda argv, **kwargs: (_ for _ in ()).throw(TargetSmokeError("boom")),
 +        )
++
 +        result = VLLM_TARGET.smoke_test(prepared)
++
 +        assert result.attempted is True
 +        assert result.ok is False
 +        assert result.detail == "boom"
++
++
 +class TestVllmHelpers:
 +    def test_default_runtime_env_is_empty_off_apple_silicon(
 +        self, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        monkeypatch.setattr("dlm.export.targets.vllm._sys_platform", lambda: "linux")
 +        monkeypatch.setattr("dlm.export.targets.vllm._machine", lambda: "x86_64")
++
 +        assert _default_runtime_env() == {}
++
 +    def test_runtime_env_validation(self) -> None:
 +        empty = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +        )
 +        assert _runtime_env(empty) == {}
++
 +        prepared = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"runtime_env": {"A": "B"}},
 +        )
 +        assert _runtime_env(prepared) == {"A": "B"}
++
 +        bad = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"runtime_env": {"A": 3}},
 +        )
 +        with pytest.raises(ExportError, match="dict\\[str, str\\]"):
 +            _runtime_env(bad)
++
 +    def test_optional_int_and_module_validation(self) -> None:
 +        prepared = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"context_length": None},
 +        )
 +        assert _optional_prepared_int(prepared, "context_length") is None
++
 +        bad_int = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"context_length": "bad"},
 +        )
 +        with pytest.raises(ExportError, match="must be an int"):
 +            _optional_prepared_int(bad_int, "context_length")
++
 +        bad_modules = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"module_specs": ("bad",)},
 +        )
 +        with pytest.raises(ExportError, match="LoraModule tuple"):
 +            _require_module_specs(bad_modules)
++
 +        good_modules = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"module_specs": (LoraModule("adapter", Path("/tmp/a"), 1),)},
 +        )
 +        assert _require_module_specs(good_modules)[0].name == "adapter"
++
 +        bad_str = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"model": ""},
 +        )
 +        with pytest.raises(ExportError, match="missing string extra"):
 +            _require_prepared_str(bad_str, "model")
++
 +        bad_required_int = TargetResult(
 +            name="vllm",
 +            export_dir=Path("/tmp/export"),
 +            manifest_path=Path("/tmp/export/export_manifest.json"),
 +            extras={"context_length": "bad"},
 +        )
 +        with pytest.raises(ExportError, match="missing int extra"):
 +            _require_prepared_int(bad_required_int, "context_length")
++
 +    def test_render_launch_script_quotes_inline_script_dir_modules(self) -> None:
 +        rendered = _render_launch_script(
 +            [
 +                "vllm",
 +                "serve",
 +                "model",
 +                "knowledge=$SCRIPT_DIR/adapters/knowledge",
 +                "$SCRIPT_DIR/direct",
 +            ],
 +            {},
 +        )
++
 +        assert 'knowledge="$SCRIPT_DIR/adapters/knowledge"' in rendered
 +        assert '"$SCRIPT_DIR/direct"' in rendered

tests/unit/export/test_dispatch.pyadded

 +"""Unit coverage for modality-aware export dispatch."""
++
 +from __future__ import annotations
++
 +from pathlib import Path
 +from types import SimpleNamespace
++
 +import pytest
++
 +from dlm.base_models import BASE_MODELS
 +from dlm.export.arch_probe import ArchProbeResult, SupportLevel
 +from dlm.export.dispatch import (
 +    DispatchResult,
 +    _load_processor_or_raise,
 +    dispatch_audio_export,
 +    dispatch_vl_export,
 +    emit_vl_snapshot,
 +)
 +from dlm.export.errors import (
 +    ExportError,
 +    ProcessorLoadError,
 +    VendoringError,
 +    VlGgufUnsupportedError,
 +)
++
 +_VL_SPEC = BASE_MODELS["qwen2-vl-2b-instruct"]
 +_AUDIO_SPEC = BASE_MODELS["qwen2-audio-7b-instruct"]
++
++
 +def _snapshot_result(tmp_path: Path, dirname: str) -> object:
 +    export_dir = tmp_path / dirname
 +    export_dir.mkdir(parents=True, exist_ok=True)
 +    manifest_path = export_dir / "export_manifest.json"
 +    manifest_path.write_text("{}", encoding="utf-8")
 +    adapter_dir = export_dir / "adapter"
 +    adapter_dir.mkdir()
 +    artifact = export_dir / "artifact.txt"
 +    artifact.write_text("ok", encoding="utf-8")
 +    return SimpleNamespace(
 +        export_dir=export_dir,
 +        manifest_path=manifest_path,
 +        adapter_dir=adapter_dir,
 +        artifacts=[artifact],
 +    )
++
++
 +class TestLoadProcessorOrRaise:
 +    def test_wraps_loader_errors(self, monkeypatch: pytest.MonkeyPatch) -> None:
 +        monkeypatch.setattr(
 +            "dlm.train.loader.load_processor",
 +            lambda spec: (_ for _ in ()).throw(RuntimeError("missing cache")),
 +        )
++
 +        with pytest.raises(ProcessorLoadError, match="missing cache"):
 +            _load_processor_or_raise(_VL_SPEC)
++
++
 +class TestEmitVlSnapshot:
 +    def test_emits_snapshot_and_warns_about_gguf_only_flags(
 +        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        processor = object()
 +        monkeypatch.setattr("dlm.train.loader.load_processor", lambda spec: processor)
 +        monkeypatch.setattr(
 +            "dlm.export.vl_snapshot.run_vl_snapshot_export",
 +            lambda store, spec, *, adapter_name, processor: _snapshot_result(
 +                tmp_path, "vl-snapshot"
 +            ),
 +        )
++
 +        result = emit_vl_snapshot(
 +            store=object(),
 +            spec=_VL_SPEC,
 +            adapter_name="named",
 +            quant="Q4_K_M",
 +            merged=True,
 +            adapter_mix_raw="tone:0.5",
 +        )
++
 +        assert result.extras["path"] == "hf-snapshot"
 +        assert any("ignoring GGUF-only flags" in line for line in result.banner_lines)
 +        assert any("HF snapshot written" in line for line in result.banner_lines)
++
 +    def test_skip_warning_suppresses_flag_banner(
 +        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        monkeypatch.setattr("dlm.train.loader.load_processor", lambda spec: object())
 +        monkeypatch.setattr(
 +            "dlm.export.vl_snapshot.run_vl_snapshot_export",
 +            lambda store, spec, *, adapter_name, processor: _snapshot_result(
 +                tmp_path, "vl-snapshot-skip-warning"
 +            ),
 +        )
++
 +        result = emit_vl_snapshot(
 +            store=object(),
 +            spec=_VL_SPEC,
 +            adapter_name=None,
 +            quant="Q4_K_M",
 +            merged=True,
 +            adapter_mix_raw="tone:0.5",
 +            skip_gguf_flag_warning=True,
 +        )
++
 +        assert not any("ignoring GGUF-only flags" in line for line in result.banner_lines)
++
++
 +class TestDispatchVlExport:
 +    def test_probe_vendoring_failure_falls_back_to_snapshot(
 +        self, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        expected = DispatchResult(
 +            export_dir=Path("/tmp/vl"),
 +            manifest_path=Path("/tmp/vl/export_manifest.json"),
 +            artifacts=[],
 +            banner_lines=["snapshot"],
 +            extras={"path": "hf-snapshot"},
 +        )
 +        monkeypatch.setattr(
 +            "dlm.export.arch_probe.probe_gguf_arch",
 +            lambda architecture: (_ for _ in ()).throw(VendoringError("missing submodule")),
 +        )
 +        monkeypatch.setattr("dlm.export.dispatch.emit_vl_snapshot", lambda **kwargs: expected)
++
 +        result = dispatch_vl_export(
 +            store=object(),
 +            spec=_VL_SPEC,
 +            adapter_name=None,
 +            quant=None,
 +            merged=False,
 +            adapter_mix_raw=None,
 +        )
++
 +        assert result.banner_lines[0].startswith(
 +            "[yellow]export:[/yellow] llama.cpp probe unavailable"
 +        )
 +        assert result.banner_lines[-1] == "snapshot"
++
 +    @pytest.mark.parametrize(
 +        ("support", "expected_text"),
 +        [
 +            (SupportLevel.UNSUPPORTED, "is not covered by the vendored llama.cpp"),
 +            (SupportLevel.PARTIAL, "has PARTIAL llama.cpp coverage"),
 +        ],
 +    )
 +    def test_unsupported_or_partial_verdicts_fall_back_to_snapshot(
 +        self,
 +        monkeypatch: pytest.MonkeyPatch,
 +        support: SupportLevel,
 +        expected_text: str,
 +    ) -> None:
 +        verdict = ArchProbeResult(
 +            arch_class=_VL_SPEC.architecture,
 +            support=support,
 +            reason="probe result",
 +            llama_cpp_tag="b1234",
 +        )
 +        expected = DispatchResult(
 +            export_dir=Path("/tmp/vl"),
 +            manifest_path=Path("/tmp/vl/export_manifest.json"),
 +            artifacts=[],
 +            banner_lines=["snapshot"],
 +            extras={"path": "hf-snapshot"},
 +        )
 +        monkeypatch.setattr("dlm.export.arch_probe.probe_gguf_arch", lambda architecture: verdict)
 +        monkeypatch.setattr("dlm.export.dispatch.emit_vl_snapshot", lambda **kwargs: expected)
++
 +        result = dispatch_vl_export(
 +            store=object(),
 +            spec=_VL_SPEC,
 +            adapter_name=None,
 +            quant=None,
 +            merged=False,
 +            adapter_mix_raw=None,
 +        )
++
 +        assert expected_text in result.banner_lines[0]
 +        assert result.banner_lines[-1] == "snapshot"
++
 +    def test_supported_without_context_falls_back_to_snapshot(
 +        self, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        verdict = ArchProbeResult(
 +            arch_class=_VL_SPEC.architecture,
 +            support=SupportLevel.SUPPORTED,
 +            reason="probe result",
 +            llama_cpp_tag="b1234",
 +        )
 +        expected = DispatchResult(
 +            export_dir=Path("/tmp/vl"),
 +            manifest_path=Path("/tmp/vl/export_manifest.json"),
 +            artifacts=[],
 +            banner_lines=["snapshot"],
 +            extras={"path": "hf-snapshot"},
 +        )
 +        monkeypatch.setattr("dlm.export.arch_probe.probe_gguf_arch", lambda architecture: verdict)
 +        monkeypatch.setattr("dlm.export.dispatch.emit_vl_snapshot", lambda **kwargs: expected)
++
 +        result = dispatch_vl_export(
 +            store=object(),
 +            spec=_VL_SPEC,
 +            adapter_name="named",
 +            quant="Q4_K_M",
 +            merged=False,
 +            adapter_mix_raw=None,
 +            gguf_emission_context=None,
 +        )
++
 +        assert "without GGUF plan context" in result.banner_lines[0]
++
 +    def test_supported_verdict_returns_vl_gguf_result(
 +        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        verdict = ArchProbeResult(
 +            arch_class=_VL_SPEC.architecture,
 +            support=SupportLevel.SUPPORTED,
 +            reason="probe result",
 +            llama_cpp_tag="b5678",
 +        )
 +        export_dir = tmp_path / "vl-gguf"
 +        export_dir.mkdir()
 +        manifest_path = export_dir / "export_manifest.json"
 +        manifest_path.write_text("{}", encoding="utf-8")
 +        gguf_path = export_dir / "model.gguf"
 +        gguf_path.write_bytes(b"gguf")
 +        modelfile_path = export_dir / "Modelfile"
 +        modelfile_path.write_text("FROM base", encoding="utf-8")
 +        mmproj_path = export_dir / "mmproj.gguf"
 +        mmproj_path.write_bytes(b"mmproj")
++
 +        monkeypatch.setattr("dlm.export.arch_probe.probe_gguf_arch", lambda architecture: verdict)
 +        monkeypatch.setattr(
 +            "dlm.export.vl_gguf.run_vl_gguf_export",
 +            lambda *args, **kwargs: SimpleNamespace(
 +                export_dir=export_dir,
 +                manifest_path=manifest_path,
 +                gguf_path=gguf_path,
 +                modelfile_path=modelfile_path,
 +                mmproj_path=mmproj_path,
 +                quant="Q4_K_M",
 +                llama_cpp_tag="b5678",
 +                artifacts=[gguf_path, modelfile_path],
 +            ),
 +        )
++
 +        result = dispatch_vl_export(
 +            store=object(),
 +            spec=_VL_SPEC,
 +            adapter_name=None,
 +            quant="Q4_K_M",
 +            merged=True,
 +            adapter_mix_raw=None,
 +            gguf_emission_context={
 +                "plan": object(),
 +                "cached_base_dir": tmp_path / "cache",
 +                "source_dlm_path": tmp_path / "doc.dlm",
 +                "dlm_version": "test",
 +                "training_sequence_len": 1024,
 +            },
 +        )
++
 +        assert result.extras["path"] == "vl-gguf"
 +        assert result.extras["gguf_path"] == gguf_path
 +        assert any(
 +            "attempting single-file VL GGUF emission" in line for line in result.banner_lines
 +        )
 +        assert any("VL GGUF written" in line for line in result.banner_lines)
++
 +    @pytest.mark.parametrize(
 +        "error",
 +        [
 +            VlGgufUnsupportedError("plan refused"),
 +            VendoringError("missing binary"),
 +            ExportError("subprocess failed"),
 +        ],
 +    )
 +    def test_supported_verdict_falls_back_after_gguf_failure(
 +        self, monkeypatch: pytest.MonkeyPatch, error: Exception
 +    ) -> None:
 +        verdict = ArchProbeResult(
 +            arch_class=_VL_SPEC.architecture,
 +            support=SupportLevel.SUPPORTED,
 +            reason="probe result",
 +            llama_cpp_tag="b1234",
 +        )
 +        expected = DispatchResult(
 +            export_dir=Path("/tmp/vl"),
 +            manifest_path=Path("/tmp/vl/export_manifest.json"),
 +            artifacts=[],
 +            banner_lines=["snapshot"],
 +            extras={"path": "hf-snapshot"},
 +        )
 +        monkeypatch.setattr("dlm.export.arch_probe.probe_gguf_arch", lambda architecture: verdict)
 +        monkeypatch.setattr(
 +            "dlm.export.vl_gguf.run_vl_gguf_export",
 +            lambda *args, **kwargs: (_ for _ in ()).throw(error),
 +        )
 +        monkeypatch.setattr("dlm.export.dispatch.emit_vl_snapshot", lambda **kwargs: expected)
++
 +        result = dispatch_vl_export(
 +            store=object(),
 +            spec=_VL_SPEC,
 +            adapter_name=None,
 +            quant="Q4_K_M",
 +            merged=True,
 +            adapter_mix_raw=None,
 +            gguf_emission_context={
 +                "plan": object(),
 +                "cached_base_dir": Path("/tmp/cache"),
 +            },
 +        )
++
 +        assert "falling back to HF-snapshot" in "\n".join(result.banner_lines)
++
++
 +class TestDispatchAudioExport:
 +    def test_audio_export_uses_snapshot_path(
 +        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        monkeypatch.setattr("dlm.train.loader.load_processor", lambda spec: object())
 +        monkeypatch.setattr(
 +            "dlm.export.audio_snapshot.run_audio_snapshot_export",
 +            lambda store, spec, *, adapter_name, processor: _snapshot_result(
 +                tmp_path, "audio-snapshot"
 +            ),
 +        )
++
 +        result = dispatch_audio_export(
 +            store=object(),
 +            spec=_AUDIO_SPEC,
 +            adapter_name="named",
 +            quant="Q4_K_M",
 +            merged=True,
 +            adapter_mix_raw="tone:0.5",
 +        )
++
 +        assert result.extras["path"] == "audio-snapshot"
 +        assert any("audio-language" in line for line in result.banner_lines)
 +        assert any("ignoring GGUF-only flags" in line for line in result.banner_lines)
 +        assert any("HF audio snapshot written" in line for line in result.banner_lines)

tests/unit/export/test_smoke.pymodified

 -"""Shared OpenAI-compatible smoke harness."""
 +"""Deterministic unit coverage for the shared OpenAI-compatible smoke helper."""
  from __future__ import annotations
 -import socket
 -import sys
 -from pathlib import Path
 +import io
 +import json
 +import subprocess
 +import urllib.error
 +from collections.abc import Callable, Iterator
  import pytest
 +from dlm.export import smoke as smoke_mod
  from dlm.export.errors import TargetSmokeError
 -from dlm.export.smoke import smoke_openai_compat_server
+-
+-
 -def _require_loopback_bind() -> None:
 -    try:
 -        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
 -            sock.bind(("127.0.0.1", 0))
 -    except PermissionError as exc:
 -        pytest.skip(f"loopback bind blocked on this host: {exc}")
+-
+-
 -def _write_server_script(tmp_path: Path, *, mode: str) -> Path:
 -    script = tmp_path / f"fake_server_{mode}.py"
 -    script.write_text(
 -        (
 -            "from __future__ import annotations\n"
 -            "import argparse\n"
 -            "import os\n"
 -            "import json\n"
 -            "from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer\n"
 -            "\n"
 -            "parser = argparse.ArgumentParser()\n"
 -            "parser.add_argument('--host', required=True)\n"
 -            "parser.add_argument('--port', required=True, type=int)\n"
 -            "parser.add_argument('--mode', required=True)\n"
 -            "args = parser.parse_args()\n"
 -            "\n"
 -            "if args.mode == 'exit':\n"
 -            "    raise SystemExit(3)\n"
 -            "if args.mode == 'env' and os.environ.get('FAKE_SMOKE_TOKEN') != 'ready':\n"
 -            "    raise SystemExit(4)\n"
 -            "\n"
 -            "class Handler(BaseHTTPRequestHandler):\n"
 -            "    def do_GET(self) -> None:\n"
 -            "        if self.path != '/v1/models':\n"
 -            "            self.send_response(404)\n"
 -            "            self.end_headers()\n"
 -            "            return\n"
 -            "        body = json.dumps({'data': [{'id': 'fake-model'}]}).encode('utf-8')\n"
 -            "        self.send_response(200)\n"
 -            "        self.send_header('Content-Type', 'application/json')\n"
 -            "        self.send_header('Content-Length', str(len(body)))\n"
 -            "        self.end_headers()\n"
 -            "        self.wfile.write(body)\n"
 -            "\n"
 -            "    def do_POST(self) -> None:\n"
 -            "        if self.path != '/v1/chat/completions':\n"
 -            "            self.send_response(404)\n"
 -            "            self.end_headers()\n"
 -            "            return\n"
 -            "        _ = self.rfile.read(int(self.headers.get('Content-Length', '0')))\n"
 -            "        if args.mode == 'empty':\n"
 -            "            payload = {'choices': [{'message': {'content': ''}}]}\n"
 -            "        else:\n"
 -            "            payload = {'choices': [{'message': {'content': 'hello from fake server'}}]}\n"
 -            "        body = json.dumps(payload).encode('utf-8')\n"
 -            "        self.send_response(200)\n"
 -            "        self.send_header('Content-Type', 'application/json')\n"
 -            "        self.send_header('Content-Length', str(len(body)))\n"
 -            "        self.end_headers()\n"
 -            "        self.wfile.write(body)\n"
 -            "\n"
 -            "    def log_message(self, format: str, *args: object) -> None:\n"
 -            "        return\n"
 -            "\n"
 -            "server = ThreadingHTTPServer((args.host, args.port), Handler)\n"
 -            "server.serve_forever()\n"
 -        ),
 -        encoding="utf-8",
 -    )
 -    return script
++
++
 +class _FakeProc:
 +    def __init__(self, *, returncode: int | None = None, kill_times_out: bool = False) -> None:
 +        self.returncode = returncode
 +        self.kill_times_out = kill_times_out
 +        self.terminated = False
 +        self.killed = False
 +        self.wait_calls = 0
++
 +    def poll(self) -> int | None:
 +        return self.returncode
++
 +    def terminate(self) -> None:
 +        self.terminated = True
++
 +    def wait(self, timeout: float) -> None:
 +        self.wait_calls += 1
 +        if self.kill_times_out and self.wait_calls == 1:
 +            raise subprocess.TimeoutExpired(cmd="fake", timeout=timeout)
++
 +    def kill(self) -> None:
 +        self.killed = True
++
++
 +class _FakeResponse:
 +    def __init__(self, payload: object) -> None:
 +        self._payload = payload
++
 +    def __enter__(self) -> _FakeResponse:
 +        return self
++
 +    def __exit__(self, *_exc: object) -> None:
 +        return None
++
 +    def read(self) -> bytes:
 +        return json.dumps(self._payload).encode("utf-8")
++
++
 +def _urlopen_with(payload: object) -> Callable[..., _FakeResponse]:
 +    def _fake_urlopen(*_args: object, **_kwargs: object) -> _FakeResponse:
 +        return _FakeResponse(payload)
++
 +    return _fake_urlopen
  class TestSmokeOpenAiCompatServer:
 -    def test_returns_first_response_line(self, tmp_path: Path) -> None:
 -        _require_loopback_bind()
 -        script = _write_server_script(tmp_path, mode="ok")
 +    def test_returns_first_response_line(self, monkeypatch: pytest.MonkeyPatch) -> None:
 +        popen_argv: list[list[str]] = []
 +        popen_env: list[dict[str, str] | None] = []
 +        stopped: list[_FakeProc] = []
 -        first_line = smoke_openai_compat_server(
 -            [sys.executable, str(script), "--mode", "ok", "--host", "127.0.0.1", "--port", "8000"]
 +        def _fake_popen(argv: list[str], **kwargs: object) -> _FakeProc:
 +            popen_argv.append(list(argv))
 +            env = kwargs.get("env")
 +            popen_env.append(env if isinstance(env, dict) else None)
 +            return _FakeProc()
++
 +        monkeypatch.setattr(smoke_mod, "reserve_local_port", lambda host: 43123)
 +        monkeypatch.setattr(smoke_mod.subprocess, "Popen", _fake_popen)
 +        monkeypatch.setattr(smoke_mod, "_wait_for_models", lambda *args, **kwargs: "fake-model")
 +        monkeypatch.setattr(
 +            smoke_mod,
 +            "_chat_completion",
 +            lambda *args, **kwargs: "\n hello from fake server \nsecond line",
 +        )
 +        monkeypatch.setattr(smoke_mod, "_stop_process", lambda proc: stopped.append(proc))
++
 +        first_line = smoke_mod.smoke_openai_compat_server(
 +            ["fake-server", "--mode", "ok", "--host", "0.0.0.0", "--port", "8000"],
 +            env={"FAKE_SMOKE_TOKEN": "ready"},
+         )
          assert first_line == "hello from fake server"
 +        assert popen_argv == [
 +            ["fake-server", "--mode", "ok", "--host", "127.0.0.1", "--port", "43123"]
 +        ]
 +        assert popen_env[0] is not None
 +        assert popen_env[0]["FAKE_SMOKE_TOKEN"] == "ready"
 +        assert len(stopped) == 1
 -    def test_empty_content_raises(self, tmp_path: Path) -> None:
 -        _require_loopback_bind()
 -        script = _write_server_script(tmp_path, mode="empty")
+-
 -        with pytest.raises(TargetSmokeError, match="non-empty"):
 -            smoke_openai_compat_server(
 -                [
 -                    sys.executable,
 -                    str(script),
 -                    "--mode",
 -                    "empty",
 -                    "--host",
 -                    "127.0.0.1",
 -                    "--port",
 -                    "8000",
 -                ]
 -            )
 +    def test_empty_content_raises(self, monkeypatch: pytest.MonkeyPatch) -> None:
 +        monkeypatch.setattr(smoke_mod, "reserve_local_port", lambda host: 42000)
 +        monkeypatch.setattr(
 +            smoke_mod.subprocess,
 +            "Popen",
 +            lambda argv, **kwargs: _FakeProc(),
 +        )
 +        monkeypatch.setattr(smoke_mod, "_wait_for_models", lambda *args, **kwargs: "fake-model")
 +        monkeypatch.setattr(smoke_mod, "_chat_completion", lambda *args, **kwargs: "  \n  ")
 +        monkeypatch.setattr(smoke_mod, "_stop_process", lambda proc: None)
++
 +        with pytest.raises(TargetSmokeError, match="empty assistant content"):
 +            smoke_mod.smoke_openai_compat_server(["fake-server"])
++
 +    def test_retries_dynamic_port_after_target_smoke_error(
 +        self, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        ports = iter((41001, 41002))
 +        popen_argv: list[list[str]] = []
 +        wait_calls = 0
++
 +        def _fake_popen(argv: list[str], **kwargs: object) -> _FakeProc:
 +            popen_argv.append(list(argv))
 +            return _FakeProc()
++
 +        def _fake_wait(*args: object, **kwargs: object) -> str | None:
 +            nonlocal wait_calls
 +            wait_calls += 1
 +            if wait_calls == 1:
 +                raise TargetSmokeError("port raced")
 +            return None
++
 +        monkeypatch.setattr(smoke_mod, "reserve_local_port", lambda host: next(ports))
 +        monkeypatch.setattr(smoke_mod.subprocess, "Popen", _fake_popen)
 +        monkeypatch.setattr(smoke_mod, "_wait_for_models", _fake_wait)
 +        monkeypatch.setattr(smoke_mod, "_chat_completion", lambda *args, **kwargs: "hello")
 +        monkeypatch.setattr(smoke_mod, "_stop_process", lambda proc: None)
++
 +        first_line = smoke_mod.smoke_openai_compat_server(["fake-server"], startup_attempts=2)
++
 +        assert first_line == "hello"
 +        assert popen_argv == [
 +            ["fake-server", "--host", "127.0.0.1", "--port", "41001"],
 +            ["fake-server", "--host", "127.0.0.1", "--port", "41002"],
 +        ]
++
 +    def test_fixed_port_does_not_retry_after_target_smoke_error(
 +        self, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        popen_argv: list[list[str]] = []
++
 +        def _fake_popen(argv: list[str], **kwargs: object) -> _FakeProc:
 +            popen_argv.append(list(argv))
 +            return _FakeProc()
++
 +        monkeypatch.setattr(smoke_mod.subprocess, "Popen", _fake_popen)
 +        monkeypatch.setattr(
 +            smoke_mod,
 +            "_wait_for_models",
 +            lambda *args, **kwargs: (_ for _ in ()).throw(TargetSmokeError("boom")),
 +        )
 +        monkeypatch.setattr(smoke_mod, "_stop_process", lambda proc: None)
++
 +        with pytest.raises(TargetSmokeError, match="boom"):
 +            smoke_mod.smoke_openai_compat_server(["fake-server"], port=49999, startup_attempts=3)
++
 +        assert popen_argv == [["fake-server", "--host", "127.0.0.1", "--port", "49999"]]
++
 +    def test_invalid_startup_attempts_raise_value_error(self) -> None:
 +        with pytest.raises(ValueError, match="startup_attempts"):
 +            smoke_mod.smoke_openai_compat_server(["fake-server"], startup_attempts=0)
++
++
 +class TestWaitForModels:
 +    def test_returns_model_id_after_retryable_fetch_error(
 +        self, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        proc = _FakeProc()
 +        seen_sleeps: list[float] = []
 +        responses: Iterator[object] = iter(
 +            [
 +                urllib.error.URLError("warming up"),
 +                "fake-model",
 +            ]
 +        )
 -    def test_early_exit_raises_with_readiness_message(self, tmp_path: Path) -> None:
 -        _require_loopback_bind()
 -        script = _write_server_script(tmp_path, mode="exit")
 +        def _fake_fetch(**kwargs: object) -> str | None:
 +            outcome = next(responses)
 +            if isinstance(outcome, Exception):
 +                raise outcome
 +            return outcome
++
 +        monkeypatch.setattr(smoke_mod, "_fetch_model_id", _fake_fetch)
 +        monkeypatch.setattr(smoke_mod.time, "sleep", lambda seconds: seen_sleeps.append(seconds))
++
 +        model_id = smoke_mod._wait_for_models(
 +            proc,
 +            io.StringIO(""),
 +            host="127.0.0.1",
 +            port=41000,
 +            startup_timeout=1.0,
 +            request_timeout=0.1,
 +            poll_interval=0.25,
 +        )
++
 +        assert model_id == "fake-model"
 +        assert seen_sleeps == [0.25]
++
 +    def test_raises_when_process_exits_before_readiness(self) -> None:
 +        proc = _FakeProc(returncode=3)
          with pytest.raises(TargetSmokeError, match="exited before readiness"):
 -            smoke_openai_compat_server(
 -                [
 -                    sys.executable,
 -                    str(script),
 -                    "--mode",
 -                    "exit",
 -                    "--host",
 -                    "127.0.0.1",
 -                    "--port",
 -                    "8000",
 -                ],
 +            smoke_mod._wait_for_models(
 +                proc,
 +                io.StringIO("first\nsecond"),
 +                host="127.0.0.1",
 +                port=41000,
                  startup_timeout=1.0,
 +                request_timeout=0.1,
 +                poll_interval=0.1,
+             )
 -    def test_passes_environment_to_subprocess(self, tmp_path: Path) -> None:
 -        _require_loopback_bind()
 -        script = _write_server_script(tmp_path, mode="env")
 +    def test_raises_timeout_with_last_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
 +        proc = _FakeProc()
 +        monotonic_values = iter((0.0, 0.05, 0.11))
 -        first_line = smoke_openai_compat_server(
 -            [sys.executable, str(script), "--mode", "env", "--host", "127.0.0.1", "--port", "8000"],
 -            env={"FAKE_SMOKE_TOKEN": "ready"},
 +        monkeypatch.setattr(smoke_mod.time, "monotonic", lambda: next(monotonic_values))
 +        monkeypatch.setattr(
 +            smoke_mod,
 +            "_fetch_model_id",
 +            lambda **kwargs: (_ for _ in ()).throw(TimeoutError("late reply")),
+         )
 +        monkeypatch.setattr(smoke_mod.time, "sleep", lambda seconds: None)
 -        assert first_line == "hello from fake server"
 +        with pytest.raises(TargetSmokeError, match="late reply"):
 +            smoke_mod._wait_for_models(
 +                proc,
 +                io.StringIO(""),
 +                host="127.0.0.1",
 +                port=41000,
 +                startup_timeout=0.1,
 +                request_timeout=0.1,
 +                poll_interval=0.05,
 +            )
++
++
 +class TestFetchModelId:
 +    @pytest.mark.parametrize(
 +        ("payload", "expected"),
 +        [
 +            ({"data": [{"id": "model-1"}]}, "model-1"),
 +            ({"data": []}, None),
 +            ({"data": ["not-a-dict"]}, None),
 +            ({"data": [{"id": "   "}]}, None),
 +        ],
 +    )
 +    def test_fetch_model_id_parses_payload(
 +        self,
 +        monkeypatch: pytest.MonkeyPatch,
 +        payload: object,
 +        expected: str | None,
 +    ) -> None:
 +        monkeypatch.setattr(
 +            smoke_mod.urllib.request,
 +            "urlopen",
 +            _urlopen_with(payload),
 +        )
++
 +        assert (
 +            smoke_mod._fetch_model_id(host="127.0.0.1", port=41000, request_timeout=0.1) == expected
 +        )
++
++
 +class TestChatCompletion:
 +    def test_returns_string_or_list_content(self, monkeypatch: pytest.MonkeyPatch) -> None:
 +        monkeypatch.setattr(
 +            smoke_mod.urllib.request,
 +            "urlopen",
 +            _urlopen_with(
 +                {
 +                    "choices": [
 +                        {
 +                            "message": {
 +                                "content": [
 +                                    {"text": "  first  "},
 +                                    {"not_text": "ignored"},
 +                                    {"text": "second"},
 +                                ]
 +                            }
 +                        }
 +                    ]
 +                }
 +            ),
 +        )
++
 +        assert (
 +            smoke_mod._chat_completion(
 +                host="127.0.0.1",
 +                port=41000,
 +                model_id=None,
 +                prompt="Hello",
 +                request_timeout=0.1,
 +            )
 +            == "first\nsecond"
 +        )
++
 +    @pytest.mark.parametrize(
 +        ("payload", "match"),
 +        [
 +            ({}, "missing choices"),
 +            ({"choices": ["bad"]}, "non-object"),
 +            ({"choices": [{}]}, "missing choices\\[0\\]\\.message"),
 +            (
 +                {"choices": [{"message": {"content": ""}}]},
 +                "missing non-empty choices\\[0\\]\\.message\\.content",
 +            ),
 +        ],
 +    )
 +    def test_raises_for_invalid_response_shapes(
 +        self,
 +        monkeypatch: pytest.MonkeyPatch,
 +        payload: object,
 +        match: str,
 +    ) -> None:
 +        monkeypatch.setattr(smoke_mod.urllib.request, "urlopen", _urlopen_with(payload))
++
 +        with pytest.raises(TargetSmokeError, match=match):
 +            smoke_mod._chat_completion(
 +                host="127.0.0.1",
 +                port=41000,
 +                model_id="model-1",
 +                prompt="Hello",
 +                request_timeout=0.1,
 +            )
++
++
 +class TestSmokeHelpers:
 +    def test_normalize_message_content(self) -> None:
 +        assert smoke_mod._normalize_message_content("  hello  ") == "hello"
 +        assert (
 +            smoke_mod._normalize_message_content(
 +                [{"text": " first "}, {"skip": True}, {"text": "second"}]
 +            )
 +            == "first\nsecond"
 +        )
 +        assert smoke_mod._normalize_message_content([{"text": "   "}]) is None
 +        assert smoke_mod._normalize_message_content(3) is None
++
 +    def test_replace_or_append_flag_and_first_non_empty_line(self) -> None:
 +        assert smoke_mod._replace_or_append_flag(["cmd"], "--host", "127.0.0.1") == [
 +            "cmd",
 +            "--host",
 +            "127.0.0.1",
 +        ]
 +        assert smoke_mod._replace_or_append_flag(["cmd", "--port"], "--port", "8000") == [
 +            "cmd",
 +            "--port",
 +            "8000",
 +        ]
 +        assert smoke_mod._first_non_empty_line("\n \nhello\nworld\n") == "hello"
 +        assert smoke_mod._first_non_empty_line(" \n\t") == ""
++
 +    def test_stop_process_kills_after_timeout(self) -> None:
 +        proc = _FakeProc(kill_times_out=True)
++
 +        smoke_mod._stop_process(proc)
++
 +        assert proc.terminated is True
 +        assert proc.killed is True
++
 +    def test_stop_process_is_noop_when_already_exited(self) -> None:
 +        proc = _FakeProc(returncode=0)
++
 +        smoke_mod._stop_process(proc)
++
 +        assert proc.terminated is False
 +        assert proc.killed is False
++
 +    def test_log_tail_and_merged_env(self) -> None:
 +        log = io.StringIO("line1\nline2\nline3")
++
 +        assert "--- server log tail ---" in smoke_mod._log_tail(log, lines=2)
 +        assert smoke_mod._merged_env({"FAKE_SMOKE_TOKEN": "ready"})["FAKE_SMOKE_TOKEN"] == "ready"