* feat(spec): hand the pending token to Proposer.propose and return a SpecProposal
* feat(engine): Sampler.probs and sparse-q rejection
* feat(spec): let a proposer declare slot states riding the GDN slots
* feat(models): export layer outputs to the feature sink in the qwen3_5 and qwen4_exp families
* feat(attention): record the source slot of each tracked request
* feat(kernel): DFlash2 draft kernels
* feat(models): DFlash2 draft family
* feat(spec): DFlashWindow
* feat(spec): DFlashProposer
* docs(cli): add dflash to the speculative decoding section
* refactor(engine): share the sampling backend choice and drop the extra renorm in Sampler.probs
* fix(models): build the DFlash rope table uncached and refuse draft scalings it does not apply
* refactor(spec): share the draft path check between the MTP and DFlash proposers
* test(e2e): compare rebuilt outputs exactly only without hybrid MoE
* refactor(spec): keep proposer slot states on EngineConfig instead of replacing model_config
* perf(spec): compute the verify distribution once for sparse-q rejection
* perf(models): let the feature sink add the residual on the rows it keeps
* perf(models): share the DFlash draft K/V weights with the ring projection
* fix(kernel): keep the dflash selector off zero-probability candidates
* test(spec): drop the DFlash tests that the draft forward and Monte Carlo tests already cover
* fix(spec): default and cap DFlash steps at the draft's block_size - 1
* fix(models): reject DFlash draft configs the draft forward cannot serve
* test(e2e): read the MoE strategy from the rebuild test's extra args
* docs(spec): say that slot-state owners write their own prefill track snapshot
* test(models): move the DFlash draft parity tests under tests/models/dflash
* refactor(spec): drop the no-op verify handler of the DFlash window
* refactor(models): fold the DFlash candidate top-k into propose
* refactor(spec): declare the draft step limits through Proposer.num_steps only
* refactor(kernel): make the DFlash ring attention stateless and keep its workspace on the ring
* refactor(models): name the DFlash draft submodules like the other model families
* refactor(spec): move SpecProposal next to DraftContext in spec/proposer.py
* refactor(spec): hand the verify the draft distribution over the whole vocabulary
* refactor(spec): call the DFlashRing object dflash_ring and its length ring_len
* refactor(models): split the DFlash draft's propose into compute_candidates and sample_path
* refactor(spec): keep the draft distribution on its support in SpecProposal
* fix(spec): drop the step's proposal once the verify has read it
* refactor(spec): name the DFlash feature sinks DFlashPrefillSink and DFlashVerifySink
* refactor(models): read the declared Batch.features directly instead of through getattr
* test(dflash): check the window rebuild inside the block forward test
* test(spec): share the plain run of the verify contract and run the DFlash draft once per family
* test(kvcache): drop the window cases from the pool tests and check a layerless state's bytes
* test(spec): check the verify probs of each row against a torch top-k and top-p reference
* test(e2e): add an accept-len floor and a prefill chunk knob to the AIME gate
* refactor(scheduler): let callers take the speculative counts from the status reporter
* test(spec): keep the shared plain runs of the verify contract in their own temp dirs
* test(models): give the ricursive test's stand-in batch a features field
* feat(ricursive): add ripple-65b preview support
* fix(ricursive): read swiglu_clamp as a per-layer gguf array
llama.cpp's Ripple converter (ggml-org/llama.cpp#31692) writes
ricursive.swiglu_clamp with one value per layer, while the first
community GGUFs store a scalar. Accept both and refuse per-layer
values that differ, since the model has a single clamp.
* fix(ricursive): add ripple's own parsers and copy the dense reader
The patch repeats every edit to a copied file and nothing checks that the two agree. The pin and the tree reproduce it. scripts/sync-llama-cpp.sh diffs the copy against the pin and merges a newer llama.cpp from it, and docs/ggml-kernels.md says how to maintain the copy.
* feat(server): report running usage on stream chunks with continuous_usage_stats
* fix(shell): count tokens instead of stream chunks in the live tok/s
* refactor(server): build both openai stream usages from GenUsage
* fix(shell): reset the first-delta count per turn and ignore zero running totals
debug_once / info_once / warning_once log on rank 0, once per distinct message and args. select_kernel, which logged its choice once per layer, and the hand-rolled log-once guards now use them.
* feat(server): report per-request prefill and decode timings in api responses
* fix(server): take timings spans from the scheduler and gate them behind --enable-timings-report
* fix(scheduler): count accepted drafts as min(n, emitted) and stamp reqstats with perf_counter
The VNNI dots were compute bound per core; with fewer instructions per weight they reach the DRAM read bandwidth.
The W4A8 kernel now follows FREETOKEN_CPU_MOE_ISA.
* feat(spec): add the MTP proposer for the qwen3_5 family
* test(models): read the qwen3_5 MTP head of bf16 and block-fp8 checkpoints
* feat(spec): verify qwen4_exp targets on qsa_sparse graphs with PLE verify handlers
* feat(spec): add the qwen4_exp MTP draft from the checkpoint or a Strata pack
* docs(cli): document the speculative decoding flags
* fix(spec): refuse MTP draft sources the draft cannot read before the target loads
* docs(qwen4_exp): describe the verify path in the PLE docstrings
* fix(spec): refuse a missing relative MTP draft path before the target loads
* fix(moe): read MTP head experts on the host and require both stacked tensors
* refactor(spec): tell the final prefill chunk from prompt_len instead of the scheduler's ChunkedReq
* refactor(spec): let each MTP draft family check its own weight source
* fix(qwen4_exp): size the disk PLE eager staging for decode and verify rows
* perf(kernel): read the KV-index gather's chunk count from the grid, not a constexpr
* refactor(moe): let each family name its MTP expert tensors
* refactor(spec): force the MTP draft's MoE resident in the proposer and check it after load
* fix(spec): refuse MTP with dummy weights
* refactor(spec): move HiddenRelay under spec/mtp, its only user
* refactor(spec): drop MTPDraft.config, fold its embed hooks into embed_tokens
* refactor(models): note FeatureSink's graph binding, drop its runtime_checkable
* fix(models): read quantized MTP fc projections under the quant config
* fix(moe): skip inactive gguf routes in hybrid decode
* perf(moe): run the inactive-route memset and zeroing only in hybrid decode
Only hybrid decode hands the GGUF kernel -1 routes, so mul_mat_id takes an inactive flag
and MMQ does the ids_src1 memset and the zeroing pass only when it is set. Prefill and
fused / offload decode go back to the main-branch MMQ calls.
* perf(moe): compare expert ids unsigned in mm_ids_helper
A negative (inactive) id compared unsigned sorts after every expert and equals none, so the
helper needs no remap to INT_MAX; the remap made nvcc unroll its token loop half as far.
* feat(spec): add the speculative verify infrastructure
* feat(scheduler): run decode steps as speculative verify steps
* chore(engine): mark the speculative decoding config fields with one comment
* feat(server): add short aliases for the speculative decoding flags
* refactor(attention): move linear-attention metadata into a LinearAttnBackend
* refactor(attention): make LinearAttnBackend a BaseAttnBackend with FLACaptureData
* refactor(attention): key every linear-attention row by fla_metadata.cache_indices
* refactor: add engine and scheduler seams for multi-row decode steps
* refactor: rename the graph steps argument to rows_per_req
* refactor: drop VerifyInfo and require rows_per_req on verify batches
* refactor: fix stale seam comments and read decode_rows_per_req directly
* refactor: reword two GraphRunner comments for multi-row graphs
* fix(engine): scale the GPU-decode MoE pool limits by decode_rows_per_req
* refactor: drop the unread Context.moe_offload_cache field
* test: trim the multi-row seam tests
* feat(scheduler): key the prefix cache by token bigrams behind radix_lookahead
* refactor(scheduler): make radix_lookahead a bool
* test(scheduler): admit radix_lookahead test requests at their prefix hit
* fix(models): find index-only checkpoints that keep shards in a subdirectory
* fix(models): make the checkpoint index authoritative for shard discovery
The index is read directly so safetensors_weight_map stays the only
header-based reader, and _host_ram_fits_parallel sizes the shards the
reader will actually open, so the low-RAM serial fallback fires again
for subdirectory layouts.
* fix(models): fall back to root shards when the index is unusable
Share one index parser between iter_weight_files and safetensors_weight_map
instead of a third copy; warn and glob the root when the index is broken,
absent or empty; reject index keys that escape the model folder; let the hub
download fetch the index itself; tell the truth in the diagnose docstring.
* revert(models): back out the defensive index fallback, keep the no-index test
Per review: a broken index is a broken checkpoint, so the loader keeps the plain one rule -- use the index if there is one, otherwise glob the root. The no-index fallback test stays as the only coverage of the root glob and the consolidated.safetensors rule.
* feat(gguf): serve image input on deepseek4 ggufs from a deepseek4v mmproj
* fix(gguf): skip an unusable deepseek4v mmproj instead of refusing the trunk
* fix(ple): add rocm disk wait-sync support
* fix(kernel): validate hip wait-sync support before enabling it
* refactor(ple): share decode fills and sync flag allocation
* fix(kernel): convert fp32 to e4m3 in one rounding on sm_89
* fix(kernel): avoid nvidia fp8 cast asm on hip
---------
Co-authored-by: zihaomu <zihaomu@outlook.com>
* feat(server): add /v1/cache/flush to drop the prefix cache when idle
* refactor(scheduler): run every cache flush at the idle safe point
* test: cover cache flush on the overlap loop and on a live server