feat(build): one-command Qwen3 genai bundle via winml build (npu + qnn)

[DingmaomaoBJTU]

Why

Exporting Qwen3 as an onnxruntime-genai bundle for the NPU previously required a bespoke scripts/qwen3.py run that emitted raw ONNX graphs and left the genai assembly to manual steps. This makes winml build produce the full, runnable genai bundle in one command, while keeping the existing per-model output unchanged for every other target.

What

For registered decoder-LLM families, winml build -m <model> -o <dir> --ep qnn targeted at the NPU now assembles a complete onnxruntime-genai bundle:

• ctx.onnx / iter.onnx - transformer prefill + decode on the NPU (QNN, w8a16)
• embeddings.onnx / lm_head.onnx - companions on CPU
• genai_config.json + tokenizer

The routing is opt-in and non-destructive: it triggers only when --ep qnn is passed explicitly together with an NPU target — either --device npu, or a --device auto that resolves to the NPU on this machine. Any other target (CPU, GPU, or an auto-detected NPU without --ep qnn) keeps today's stock composite build.

All model-specific detail lives in a data-only genai-bundle recipe registered by the model package (GenaiBundleRecipe + build_genai_bundle), so the winml build routing itself stays architecture-agnostic. scripts/qwen3.py is thinned to delegate to the same orchestrator, and registering a recipe for another decoder family is all that is needed to give it the same one-command build.

Reproduce (NPU + CPU hybrid)

The bundle runs as an NPU + CPU hybrid: the transformer stages (ctx / iter) execute on the QNN HTP while embeddings and lm_head run on CPU. The split is encoded per stage in the bundle's genai_config.json, so --device auto ("mixed") honors it without any extra flags.

# 1. Build the bundle in one command. --device auto resolves to the NPU here;
#    --device npu is equivalent.
winml build -m Qwen/Qwen3-0.6B -o out/qwen3-bundle --device auto --ep qnn

# 2. Pre-compile each QNN stage to an EPContext binary under _compiled/.
#    This may exit with a native teardown crash *after* the artifacts are
#    written to disk; the salvage path recovers them (see Notable).
winml perf -m out/qwen3-bundle --runtime winml-genai --device auto --compile

# 3. Benchmark the pre-compiled bundle in a fresh process (no --compile).
#    Loading _compiled/ directly is the stable path — it skips the fragile
#    in-process compile-then-load.
winml perf -m out/qwen3-bundle/_compiled --runtime winml-genai --device auto \
    --iterations 10 --warmup 2 --max-new-tokens 64

Observed on a Snapdragon X Elite NPU (step 3, hybrid, HTP burst mode): TTFT ~136 ms, decode ~21.6 tok/s (~46 ms/token), stable across repeated runs.

Notable

• Routing bug fix (found during e2e). WinMLAutoModel.from_pretrained computed an explicit model_type override but then delegated to the base composite from_pretrained, which re-derived the native model_type and built the stock graph, breaking quantization/calibration. It now resolves the concrete composite class for the overridden type. This is the fix that actually lets the surgical bundle build succeed.
• Compile once, then run directly. onnxruntime-genai compiles the QNN context in-memory at model creation, which faults before the first token when done in the same process that also just prepared the bundle. The reliable pattern is the two-step workflow above: --compile once to produce _compiled/, then benchmark -m <bundle>/_compiled in a fresh process. Documented in the sample.
• Teardown crash is now salvaged. The --compile step may still exit with a native 0xC0000374 / 0xC0000005 during QNN-EP teardown, after each stage's EPContext is written. The salvage path recovers the valid _compiled/ artifacts from that crash, so the subsequent direct run succeeds. The crash originates in the native runtime below winml-cli and does not affect the generated tokens or the saved perf metrics.

Verification

• Scoped unit tests green across the genai-bundle registry/orchestrator, build routing (including --device auto), the script device→EP mapping, and the --no-quant rejection guard; ruff clean.
• End to end on a Snapdragon X Elite NPU via the two-step workflow above: winml build ... --ep qnn produced the bundle, --compile wrote _compiled/, and the fresh-process run generated tokens on the QNN HTP as an NPU+CPU hybrid (TTFT ~136 ms, decode ~21.6 tok/s).