From 1f635e075e68dc072a48ccd4b245c145a45327f5 Mon Sep 17 00:00:00 2001 From: David Roth Date: Wed, 8 Jul 2026 22:46:15 -0500 Subject: [PATCH 01/10] feat(vision): native mmproj prefill with per-request DFlash routing. Load mmproj alongside draft, parse image_url in HTTP server, inject vision embeddings in Qwen35 prefill, and keep speculative decode for text-only requests while forcing AR on multimodal turns. --- server/CMakeLists.txt | 40 ++++ server/scripts/entrypoint.sh | 4 + server/src/common/backend_args.h | 4 + server/src/common/backend_factory.cpp | 2 + server/src/common/model_backend.h | 53 +++++ server/src/common/vision_types.h | 24 +++ server/src/qwen35/qwen35_backend.cpp | 286 +++++++++++++++++++++++++- server/src/qwen35/qwen35_backend.h | 23 +++ server/src/server/http_server.cpp | 35 ++++ server/src/server/http_server.h | 6 + server/src/server/server_main.cpp | 19 ++ server/src/vision/vision_encoder.cpp | 139 +++++++++++++ server/src/vision/vision_encoder.h | 80 +++++++ server/src/vision/vision_input.cpp | 176 ++++++++++++++++ server/src/vision/vision_input.h | 34 +++ 15 files changed, 922 insertions(+), 3 deletions(-) create mode 100644 server/src/common/vision_types.h create mode 100644 server/src/vision/vision_encoder.cpp create mode 100644 server/src/vision/vision_encoder.h create mode 100644 server/src/vision/vision_input.cpp create mode 100644 server/src/vision/vision_input.h diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index 0da29ea33..45decd074 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -203,6 +203,23 @@ endif() # Use only the ggml subtree of llama.cpp (skip libllama). add_subdirectory(deps/llama.cpp/ggml EXCLUDE_FROM_ALL) +# Optional native mmproj vision (mtmd + llama for tokenization/vocab). +option(DFLASH27B_MMPROJ "Build native mmproj vision support via mtmd" OFF) +if(DFLASH27B_MMPROJ) + set(LLAMA_BUILD_COMMON OFF CACHE BOOL "" FORCE) + set(LLAMA_BUILD_TESTS OFF CACHE BOOL "" FORCE) + set(LLAMA_BUILD_TOOLS OFF CACHE BOOL "" FORCE) + set(LLAMA_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) + set(LLAMA_BUILD_SERVER OFF CACHE BOOL "" FORCE) + add_subdirectory(deps/llama.cpp EXCLUDE_FROM_ALL) + # mtmd is added as a sibling of llama.cpp (not via tools/) so + # LLAMA_INSTALL_VERSION must be visible in the parent scope. + if(NOT DEFINED LLAMA_INSTALL_VERSION) + set(LLAMA_INSTALL_VERSION "0.0.0") + endif() + add_subdirectory(deps/llama.cpp/tools/mtmd EXCLUDE_FROM_ALL) +endif() + if(DFLASH27B_GPU_BACKEND STREQUAL "hip") # The vendored ggml HIP shim still uses a few CUDA spellings that are not # mapped in this upstream snapshot. Keep the compatibility layer in this @@ -238,6 +255,7 @@ set(DFLASH27B_SRC_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src/gemma4 ${CMAKE_CURRENT_SOURCE_DIR}/src/deepseek4 ${CMAKE_CURRENT_SOURCE_DIR}/src/server + ${CMAKE_CURRENT_SOURCE_DIR}/src/vision ) add_library(dflash_common STATIC @@ -344,6 +362,7 @@ add_library(dflash_common STATIC src/server/prefix_cache.cpp src/server/disk_prefix_cache.cpp src/server/freeze_history.cpp + src/vision/vision_input.cpp # ── Jinja chat-template engine (vendored under deps/llama.cpp/common/) ── # Used by render_chat_template_jinja() to support --chat-template-file # in dflash_server. Mirrors llama.cpp's common_chat_template plumbing. @@ -357,6 +376,9 @@ add_library(dflash_common STATIC deps/llama.cpp/common/jinja/caps.cpp deps/llama.cpp/common/unicode.cpp ) +if(DFLASH27B_MMPROJ) + target_sources(dflash_common PRIVATE src/vision/vision_encoder.cpp) +endif() # BSA (Block-Sparse Attention) backs the speculative-prefill drafter scoring # path. Default ON so prefill is fast out of the box. Turn OFF if you don't # run the spec-prefill stack or are building without CUDA BF16 WMMA support @@ -579,6 +601,16 @@ if(DFLASH27B_ENABLE_BSA) endif() endif() +if(DFLASH27B_MMPROJ) + target_compile_definitions(dflash_common PRIVATE DFLASH_HAVE_MMPROJ=1) + set(DFLASH27B_MMPROJ_INCLUDE_DIRS + ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/include + ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/tools/mtmd + ${CMAKE_CURRENT_SOURCE_DIR}/deps/llama.cpp/vendor) + target_include_directories(dflash_common PRIVATE ${DFLASH27B_MMPROJ_INCLUDE_DIRS}) + target_link_libraries(dflash_common PRIVATE llama mtmd) +endif() + target_include_directories(dflash_common PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include @@ -1133,6 +1165,10 @@ if(DFLASH27B_TESTS) else() target_link_libraries(test_server_unit PRIVATE hip::host) endif() + if(DFLASH27B_MMPROJ) + target_compile_definitions(test_server_unit PRIVATE DFLASH_HAVE_MMPROJ=1) + target_include_directories(test_server_unit PRIVATE ${DFLASH27B_MMPROJ_INCLUDE_DIRS}) + endif() if(CMAKE_CROSSCOMPILING) # Runtime discovery cannot execute a target binary on the build # host. Register one aggregate test instead; CMake prepends the @@ -1312,6 +1348,10 @@ if(DFLASH27B_SERVER) DFLASH27B_BACKEND_CUDA=1 DFLASH27B_CUDA_MIN_SM=${_dflash_cuda_min_sm}) endif() + if(DFLASH27B_MMPROJ) + target_compile_definitions(dflash_server PRIVATE DFLASH_HAVE_MMPROJ=1) + target_include_directories(dflash_server PRIVATE ${DFLASH27B_MMPROJ_INCLUDE_DIRS}) + endif() if(NOT WIN32) target_link_libraries(dflash_server PRIVATE dflash_common ggml ${DFLASH27B_GGML_BACKEND_TARGET} pthread) else() diff --git a/server/scripts/entrypoint.sh b/server/scripts/entrypoint.sh index 2602517f5..0759cb1e2 100755 --- a/server/scripts/entrypoint.sh +++ b/server/scripts/entrypoint.sh @@ -315,6 +315,8 @@ fi # the KV footprint. Only emitted to the server CLI when nonzero so # unset reproduces the server's own default unchanged. : "${DFLASH_FA_WINDOW:=0}" +# Native mmproj vision projector (Qwen3-VL etc.). When set, passed as --mmproj. +: "${DFLASH_MMPROJ:=}" # ── auto-detect target ───────────────────────────────────────────────────── # Target .gguf is typically 10-30 GB (Q4_K_M). Drafts are 1-2 GB (Q8_0 / Q4) @@ -499,6 +501,8 @@ CMD=("$DFLASH_SERVER_BIN" "$DFLASH_TARGET" [ -n "$DRAFT_ARG" ] && CMD+=(--draft "$DRAFT_ARG") [ -n "$DRAFT_ARG" ] && CMD+=(--ddtree --ddtree-budget "$DFLASH_BUDGET") +[ -n "$DFLASH_MMPROJ" ] && CMD+=(--mmproj "$DFLASH_MMPROJ") +[ "${DFLASH_MMPROJ_NO_OFFLOAD:-0}" = "1" ] && [ -n "$DFLASH_MMPROJ" ] && CMD+=(--no-mmproj-offload) [ -n "$DFLASH_DEFAULT_MAX_TOKENS" ] && CMD+=(--default-max-tokens "$DFLASH_DEFAULT_MAX_TOKENS") [ -n "$DFLASH_MODEL_NAME" ] && CMD+=(--model-name "$DFLASH_MODEL_NAME") # `--lazy-draft` is silently dropped by the C++ server unless both diff --git a/server/src/common/backend_args.h b/server/src/common/backend_args.h index 1607b1495..ed957a53b 100644 --- a/server/src/common/backend_args.h +++ b/server/src/common/backend_args.h @@ -36,6 +36,10 @@ struct BackendArgs { // Optional: speculative decode draft model (qwen35 only) const char * draft_path = nullptr; + // Native mmproj vision (qwen35) + const char * mmproj_path = nullptr; + bool mmproj_use_gpu = true; + // Device placement DevicePlacement device; DevicePlacement draft_device; diff --git a/server/src/common/backend_factory.cpp b/server/src/common/backend_factory.cpp index ab34f2a19..0d3633da4 100644 --- a/server/src/common/backend_factory.cpp +++ b/server/src/common/backend_factory.cpp @@ -270,6 +270,8 @@ std::unique_ptr create_backend( cfg.ddtree_temp = args.ddtree_temp; cfg.ddtree_chain_seed = args.ddtree_chain_seed; cfg.use_feature_mirror = args.use_feature_mirror; + cfg.mmproj_path = args.mmproj_path; + cfg.mmproj_use_gpu = args.mmproj_use_gpu; auto backend = std::make_unique(cfg); if (!backend->init()) { diff --git a/server/src/common/model_backend.h b/server/src/common/model_backend.h index 8c072121d..4380c9f0e 100644 --- a/server/src/common/model_backend.h +++ b/server/src/common/model_backend.h @@ -13,12 +13,15 @@ #include #include #include +#include #include #include #include #include #include +#include "vision_types.h" + #include "ggml.h" #include "ggml-backend.h" #include "sampler.h" @@ -177,8 +180,58 @@ struct GenerateRequest { // path returns success but emits no tokens, so each backend can route the // retry through its existing AR path without copying retry policy. bool force_ar_decode = false; + // Native mmproj vision prompt. When set, backends run multimodal prefill + // instead of token-id prefill and force AR decode. + std::unique_ptr multimodal; + + GenerateRequest() = default; + GenerateRequest(const GenerateRequest & other); + GenerateRequest & operator=(const GenerateRequest & other); + GenerateRequest(GenerateRequest &&) noexcept = default; + GenerateRequest & operator=(GenerateRequest &&) noexcept = default; }; +inline GenerateRequest::GenerateRequest(const GenerateRequest & other) + : prompt(other.prompt), + n_gen(other.n_gen), + sampler(other.sampler), + do_sample(other.do_sample), + stream(other.stream), + snap_pos(other.snap_pos), + snap_slot(other.snap_slot), + on_token(other.on_token), + hint_tokens(other.hint_tokens), + stall_tool_prefix_tokens(other.stall_tool_prefix_tokens), + stall_action_suffix_tokens(other.stall_action_suffix_tokens), + stall_skip_tokens(other.stall_skip_tokens), + budget_hook(other.budget_hook), + force_ar_decode(other.force_ar_decode), + multimodal(other.multimodal + ? std::make_unique(*other.multimodal) + : nullptr) {} + +inline GenerateRequest & GenerateRequest::operator=(const GenerateRequest & other) { + if (this == &other) return *this; + prompt = other.prompt; + n_gen = other.n_gen; + sampler = other.sampler; + do_sample = other.do_sample; + stream = other.stream; + snap_pos = other.snap_pos; + snap_slot = other.snap_slot; + on_token = other.on_token; + hint_tokens = other.hint_tokens; + stall_tool_prefix_tokens = other.stall_tool_prefix_tokens; + stall_action_suffix_tokens = other.stall_action_suffix_tokens; + stall_skip_tokens = other.stall_skip_tokens; + budget_hook = other.budget_hook; + force_ar_decode = other.force_ar_decode; + multimodal = other.multimodal + ? std::make_unique(*other.multimodal) + : nullptr; + return *this; +} + // Stable, backend-independent generation failure categories. Backends should // use these for recurrent failures so callers do not need to understand // architecture-specific strings. `generate_error_code()` is the daemon/API diff --git a/server/src/common/vision_types.h b/server/src/common/vision_types.h new file mode 100644 index 000000000..118c3a5e4 --- /dev/null +++ b/server/src/common/vision_types.h @@ -0,0 +1,24 @@ +// Multimodal prompt types for native mmproj vision integration. + +#pragma once + +#include +#include +#include + +namespace dflash::common { + +// Raw image bytes (JPEG/PNG/etc.) decoded from a data: URL or API payload. +struct DecodedImage { + std::vector bytes; +}; + +// A prompt with mtmd media markers embedded in marked_text plus parallel +// image payloads. marked_text must contain one mtmd_default_marker() per +// image (in order) before tokenize() is called. +struct MultimodalPrompt { + std::string marked_text; + std::vector images; +}; + +} // namespace dflash::common diff --git a/server/src/qwen35/qwen35_backend.cpp b/server/src/qwen35/qwen35_backend.cpp index 8c83bc2b8..ca1a29900 100644 --- a/server/src/qwen35/qwen35_backend.cpp +++ b/server/src/qwen35/qwen35_backend.cpp @@ -39,6 +39,12 @@ #include "kv_quant.h" +#ifdef DFLASH_HAVE_MMPROJ +#include "vision_encoder.h" +#include "mtmd.h" +#include "mtmd-helper.h" +#endif + namespace dflash::common { namespace { @@ -334,6 +340,18 @@ bool Qwen35Backend::init() { } } +#ifdef DFLASH_HAVE_MMPROJ + if (cfg_.mmproj_path) { + vision_ = std::make_unique(); + const int n_threads = env_int_or_default("DFLASH_MMPROJ_THREADS", 4); + if (!vision_->init(cfg_.target_path, cfg_.mmproj_path, + cfg_.mmproj_use_gpu, n_threads)) { + std::fprintf(stderr, "[qwen35] VisionEncoder init failed\n"); + return false; + } + } +#endif + return true; } @@ -806,7 +824,24 @@ GenerateResult Qwen35Backend::generate_impl(const GenerateRequest & req, // Prefill auto t_prefill_start = std::chrono::steady_clock::now(); - const int committed = do_prefill(req.prompt, out_io, req.snap_pos, req.snap_slot); + const bool use_multimodal = req.multimodal && !req.multimodal->images.empty(); +#ifdef DFLASH_HAVE_MMPROJ + const bool vision_ready = vision_ && vision_->ready(); +#else + const bool vision_ready = false; +#endif + int committed = -1; + if (use_multimodal) { + if (!vision_ready) { + result.fail(GenerateErrorCode::AdapterUnavailable, + "vision not configured"); + return result; + } + committed = do_prefill_multimodal(*req.multimodal, out_io, + req.snap_pos, req.snap_slot); + } else { + committed = do_prefill(req.prompt, out_io, req.snap_pos, req.snap_slot); + } if (committed < 0) { result.fail(GenerateErrorCode::PrefillFailed); return result; @@ -824,7 +859,8 @@ GenerateResult Qwen35Backend::generate_impl(const GenerateRequest & req, // generation. Most requests never hit the tail because the // model closes naturally well before the budget edge. bool decode_ok = false; - if (req.force_ar_decode) { + const bool force_ar = req.force_ar_decode || use_multimodal; + if (force_ar) { decode_ok = do_ar_decode(committed, req.n_gen, result.tokens, out_io, req.budget_hook, &result.budget_forced_close, @@ -963,6 +999,8 @@ GenerateResult Qwen35Backend::restore_and_generate_impl(int slot, } } + const bool use_multimodal = req.multimodal && !req.multimodal->images.empty(); + // Decode if (req.n_gen > 0) { auto t_decode_start = std::chrono::steady_clock::now(); @@ -973,7 +1011,8 @@ GenerateResult Qwen35Backend::restore_and_generate_impl(int slot, // generation. Most requests never hit the tail because the // model closes naturally well before the budget edge. bool decode_ok = false; - if (req.force_ar_decode) { + const bool force_ar = req.force_ar_decode || use_multimodal; + if (force_ar) { decode_ok = do_ar_decode(committed, req.n_gen, result.tokens, out_io, req.budget_hook, &result.budget_forced_close, @@ -1281,6 +1320,247 @@ int Qwen35Backend::do_prefill(const std::vector & tokens, return committed; } +#ifdef DFLASH_HAVE_MMPROJ + +namespace { + +void build_bidirectional_mask(std::vector & out, + int kv_len, int n_tokens, int kv_pos, + int kq_stride_pad, int kv_pad_override = 0) { + const int kv_pad = (kv_pad_override > 0) ? kv_pad_override + : align_up(kv_len, kq_stride_pad); + const int q_pad = align_up(n_tokens, KQ_MASK_PAD); + out.assign((size_t)kv_pad * q_pad, F16_NEG_INF); + for (int q = 0; q < n_tokens; q++) { + for (int k = 0; k < kv_pos; k++) { + out[(size_t)q * kv_pad + k] = F16_ZERO; + } + for (int k = kv_pos; k < kv_pos + n_tokens; k++) { + out[(size_t)q * kv_pad + k] = F16_ZERO; + } + } +} + +} // namespace + +bool Qwen35Backend::do_prefill_embed_chunk(int kv_pos, int n_tokens, + const float * embeds, int hidden, + const std::vector & pos_buf, + bool with_mask, + bool last_token_logits_only, + bool non_causal_within_chunk) { + if (!build_target_step(sg_, w_, cache_, target_backend_, + /*kv_start=*/kv_pos, /*n_tokens=*/n_tokens, + with_mask, /*capture=*/true, + /*capture_delta_intermediate=*/false, + /*fa_window=*/0, + /*last_token_logits_only=*/last_token_logits_only, + cfg_.kq_stride_pad, + should_capture_moe_router(), + /*kvflash_mask=*/false)) { + std::fprintf(stderr, "multimodal prefill build @%d\n", kv_pos); + return false; + } + + ggml_backend_tensor_set(sg_.inp_embed, embeds, 0, + sizeof(float) * (size_t)hidden * (size_t)n_tokens); + ggml_backend_tensor_set(sg_.positions, pos_buf.data(), 0, + sizeof(int32_t) * pos_buf.size()); + + if (sg_.attn_mask) { + const int kv_len = kv_pos + n_tokens; + std::vector mask_buf; + const int kv_pad_override = (int)sg_.attn_mask->ne[0]; + if (non_causal_within_chunk) { + build_bidirectional_mask(mask_buf, kv_len, n_tokens, kv_pos, + cfg_.kq_stride_pad, kv_pad_override); + } else { + build_causal_mask(mask_buf, kv_len, n_tokens, kv_pos, + cfg_.kq_stride_pad, 0, kv_pad_override); + } + ggml_backend_tensor_set(sg_.attn_mask, mask_buf.data(), 0, + sizeof(uint16_t) * mask_buf.size()); + } + + auto st = ggml_backend_graph_compute(target_backend_, sg_.gf); + if (st != GGML_STATUS_SUCCESS) { + std::fprintf(stderr, "multimodal prefill compute @%d failed\n", kv_pos); + return false; + } + after_target_compute(sg_, kv_pos, n_tokens); + return true; +} + +int Qwen35Backend::do_prefill_multimodal(MultimodalPrompt & mm, + const DaemonIO & io, + int snap_pos, int snap_slot, + int kv_offset) { + (void)io; + if (!vision_ || !vision_->ready()) { + std::fprintf(stderr, "[vision] encoder not initialized\n"); + return -1; + } + if (kv_offset != 0) { + std::fprintf(stderr, "[vision] multimodal restore prefill unsupported\n"); + return -1; + } + + const int hidden = w_.n_embd; + const int vocab = w_.n_vocab; + prefill_last_logits_valid_ = false; + reset_recurrent_state(cache_); + + mtmd_input_chunks * chunks = vision_->tokenize(mm.marked_text, mm.images); + if (!chunks) return -1; + + struct ChunksGuard { + mtmd_input_chunks * p; + ~ChunksGuard() { if (p) mtmd_input_chunks_free(p); } + } chunks_guard{chunks}; + + const size_t n_chunks = mtmd_input_chunks_size(chunks); + if (n_chunks == 0) return 0; + + const int max_verify_tokens = cfg_.ddtree_mode + ? std::max(dw_.block_size, cfg_.ddtree_budget + 1) + : dw_.block_size; + if (!migrate_prefill_cache(w_, cfg_.device.max_ctx, + max_verify_tokens, + target_backend_, cache_)) { + std::fprintf(stderr, "multimodal prefill: cache migration failed: %s\n", + dflash27b_last_error()); + return -1; + } + + std::vector embed_buf; + int committed = kv_offset; + + for (size_t ci = 0; ci < n_chunks; ci++) { + const mtmd_input_chunk * chunk = mtmd_input_chunks_get(chunks, ci); + const auto chunk_type = mtmd_input_chunk_get_type(chunk); + const bool is_last_chunk = (ci + 1 == n_chunks); + const int kv_pos = committed; + + if (chunk_type == MTMD_INPUT_CHUNK_TYPE_TEXT) { + size_t n_tokens_sz = 0; + const llama_token * toks = + mtmd_input_chunk_get_tokens_text(chunk, &n_tokens_sz); + const int n_tokens = (int)n_tokens_sz; + if (n_tokens <= 0) continue; + + std::vector tokens(n_tokens); + for (int i = 0; i < n_tokens; i++) tokens[(size_t)i] = (int32_t)toks[i]; + + embed_buf.resize((size_t)hidden * (size_t)n_tokens); + if (!w_.embedder.embed(tokens.data(), n_tokens, embed_buf.data())) { + return -1; + } + + std::vector pos_buf((size_t)4 * (size_t)n_tokens, 0); + for (int i = 0; i < n_tokens; i++) { + const int p = kv_pos + i; + pos_buf[4 * i + 0] = p; + pos_buf[4 * i + 1] = p; + pos_buf[4 * i + 2] = p; + pos_buf[4 * i + 3] = 0; + } + + const bool with_mask = (cfg_.kq_stride_pad > KQ_MASK_PAD) || (n_tokens > 1); + if (!do_prefill_embed_chunk(kv_pos, n_tokens, embed_buf.data(), hidden, + pos_buf, with_mask, + /*last_token_logits_only=*/!is_last_chunk, + /*non_causal_within_chunk=*/false)) { + return -1; + } + + committed = kv_pos + n_tokens; + } else if (chunk_type == MTMD_INPUT_CHUNK_TYPE_IMAGE || + chunk_type == MTMD_INPUT_CHUNK_TYPE_AUDIO) { + const int n_tokens = (int)mtmd_input_chunk_get_n_tokens(chunk); + if (n_tokens <= 0) continue; + + if (!vision_->encode_chunk(chunk)) return -1; + float * embd = vision_->output_embeddings(); + if (!embd) return -1; + + std::vector pos_buf; + if (vision_->uses_mrope() && + chunk_type == MTMD_INPUT_CHUNK_TYPE_IMAGE) { + const auto * image_tokens = mtmd_input_chunk_get_tokens_image(chunk); + if (!image_tokens) return -1; + std::vector rel_pos((size_t)n_tokens); + vision_->get_image_decoder_pos(image_tokens, rel_pos.data(), + (size_t)n_tokens); + pos_buf.resize((size_t)4 * (size_t)n_tokens, 0); + for (int i = 0; i < n_tokens; i++) { + pos_buf[4 * i + 0] = kv_pos + (int)rel_pos[(size_t)i].t; + pos_buf[4 * i + 1] = kv_pos + (int)rel_pos[(size_t)i].y; + pos_buf[4 * i + 2] = kv_pos + (int)rel_pos[(size_t)i].x; + pos_buf[4 * i + 3] = 0; + } + } else { + pos_buf.resize((size_t)4 * (size_t)n_tokens, 0); + for (int i = 0; i < n_tokens; i++) { + const int p = kv_pos + i; + pos_buf[4 * i + 0] = p; + pos_buf[4 * i + 1] = p; + pos_buf[4 * i + 2] = p; + pos_buf[4 * i + 3] = 0; + } + } + + const bool non_causal = vision_->uses_non_causal(chunk); + const bool with_mask = non_causal || (cfg_.kq_stride_pad > KQ_MASK_PAD) || + (n_tokens > 1); + if (!do_prefill_embed_chunk(kv_pos, n_tokens, embd, hidden, + pos_buf, with_mask, + /*last_token_logits_only=*/!is_last_chunk, + non_causal)) { + return -1; + } + + committed = kv_pos + (int)mtmd_input_chunk_get_n_pos(chunk); + } else { + std::fprintf(stderr, "[vision] unsupported mtmd chunk type\n"); + return -1; + } + + cache_.cur_pos = committed; + + const int chunk_kv_len = committed - kv_pos; + if (chunk_kv_len > 0) { + if (remote_draft_.active() && !draft_parked_) { + if (!sync_remote_draft_features(kv_pos, chunk_kv_len)) return -1; + } else if (feature_mirror_.target_feat && !draft_parked_) { + draft_feature_mirror_sync_range(cache_.target_feat, cache_.target_feat_cap, + feature_mirror_, kv_pos, chunk_kv_len); + } + } + + int32_t last_tok = -1; + ggml_backend_tensor_get(sg_.argmax_tokens, &last_tok, 0, sizeof(int32_t)); + cache_.last_tok = last_tok; + if (is_last_chunk) { + prefill_last_logits_offset_ = + (size_t)(mtmd_input_chunk_get_n_tokens(chunk) - 1) * + (size_t)vocab * sizeof(float); + prefill_last_logits_valid_ = true; + } + } + + if (snap_slot >= 0 && snap_pos == committed) { + if (snapshot_save(snap_slot)) { + std::printf("[snap] multimodal end-of-prefill slot=%d cur_pos=%d\n", + snap_slot, committed); + std::fflush(stdout); + } + } + + return committed; +} + +#endif // DFLASH_HAVE_MMPROJ + // ── kvflash helpers ───────────────────────────────────────────────── void Qwen35Backend::kvflash_sync_prefill(int committed, diff --git a/server/src/qwen35/qwen35_backend.h b/server/src/qwen35/qwen35_backend.h index d14f931f7..bb6a0a487 100644 --- a/server/src/qwen35/qwen35_backend.h +++ b/server/src/qwen35/qwen35_backend.h @@ -34,6 +34,10 @@ #include #include +namespace dflash::common { +class VisionEncoder; +} + namespace dflash::common { class Qwen35TensorParallelContext; @@ -70,6 +74,10 @@ struct Qwen35Config { float ddtree_temp = 1.0f; bool ddtree_chain_seed = true; bool use_feature_mirror = false; + + // Native mmproj vision + const char * mmproj_path = nullptr; + bool mmproj_use_gpu = true; }; // ── Backend class ─────────────────────────────────────────────────────── @@ -266,6 +274,10 @@ class Qwen35Backend : public ModelBackend { // ── DFlashTarget adapter (lazy-built) ──────────────────────────── std::unique_ptr dflash_target_; +#ifdef DFLASH_HAVE_MMPROJ + std::unique_ptr vision_; +#endif + // ── Internal helpers ───────────────────────────────────────────── // Prefill a prompt and return the number of tokens committed to KV. // kv_offset > 0 resumes from a restored snapshot: tokens are placed at @@ -275,6 +287,17 @@ class Qwen35Backend : public ModelBackend { int snap_pos = -1, int snap_slot = -1, int kv_offset = 0); + int do_prefill_multimodal(MultimodalPrompt & mm, + const DaemonIO & io, + int snap_pos = -1, int snap_slot = -1, + int kv_offset = 0); + + bool do_prefill_embed_chunk(int kv_pos, int n_tokens, + const float * embeds, int hidden, + const std::vector & pos_buf, + bool with_mask, bool last_token_logits_only, + bool non_causal_within_chunk); + // Speculative decode loop: draft → verify → accept until EOS/max. // When budget_hook is non-null and (n_gen - generated) drops to the // hard-limit boundary, breaks out of the spec-decode loop and tails diff --git a/server/src/server/http_server.cpp b/server/src/server/http_server.cpp index 46081fa23..b26925897 100644 --- a/server/src/server/http_server.cpp +++ b/server/src/server/http_server.cpp @@ -23,6 +23,11 @@ #include "tool_hint.h" #include "common/sha1.h" #include "freeze_history.h" +#include "vision/vision_input.h" + +#ifdef DFLASH_HAVE_MMPROJ +#include "mtmd.h" +#endif #ifdef DFLASH_HAS_CURL #include @@ -737,6 +742,7 @@ json build_props_body(const ServerConfig & config, {"reasoning_supported", reasoning_supported}, {"speculative_supported", speculative_supported}, {"tools_supported", tools_supported}, + {"vision_supported", config.vision_supported}, }}, }; return body; @@ -850,10 +856,18 @@ std::vector normalize_chat_messages( cm.content = m["content"].get(); } else if (m.contains("content") && m["content"].is_array()) { for (const auto & part : m["content"]) { + if (!part.is_object()) continue; std::string ptype = part.value("type", ""); if (ptype == "text" || ptype == "input_text" || ptype == "output_text") { cm.content += part.value("text", ""); + } else if (ptype == "image_url" || ptype == "input_image" || + ptype == "image") { +#ifdef DFLASH_HAVE_MMPROJ + cm.content += mtmd_default_marker(); +#else + cm.content += "<__media__>"; +#endif } } } @@ -1764,6 +1778,22 @@ bool HttpServer::render_and_tokenize_request( } req.started_in_thinking = prompt_ends_in_open_think(rendered); + if (messages_contain_images(req.messages)) { + if (config_.mmproj_path.empty()) { + send_error(fd, 400, + "vision input requires --mmproj (no mmproj model loaded)"); + return false; + } + MultimodalPrompt extracted = extract_multimodal_from_messages(req.messages); + if (extracted.images.empty()) { + send_error(fd, 400, "failed to decode vision input"); + return false; + } + auto mm = std::make_unique(); + mm->marked_text = rendered; + mm->images = std::move(extracted.images); + req.multimodal = std::move(mm); + } req.prompt_tokens = tokenizer_.encode(rendered); return true; } @@ -3095,6 +3125,11 @@ void HttpServer::prepare_generation_inputs( : req.max_output; inputs.request.prompt = prepared.tokens; + if (req.multimodal) { + inputs.request.multimodal = + std::make_unique(*req.multimodal); + inputs.request.force_ar_decode = true; + } inputs.request.n_gen = inputs.generation_cap; inputs.request.sampler = req.sampler; inputs.request.do_sample = req.sampler.needs_logit_processing(); diff --git a/server/src/server/http_server.h b/server/src/server/http_server.h index 56f555369..c391a6293 100644 --- a/server/src/server/http_server.h +++ b/server/src/server/http_server.h @@ -181,6 +181,10 @@ struct ServerConfig { std::string chat_template_src; // literal Jinja source (loaded from file) std::string chat_template_path; // path it was loaded from (logged at startup) + // Native mmproj vision + std::string mmproj_path; + bool vision_supported = false; + // Expert frequency tracking (--freq): print frequency analysis at shutdown. bool freq_tracking = false; @@ -228,6 +232,8 @@ struct ParsedRequest { // Bandit: per-session adaptive keep_ratio opt-in std::string session_id; DiskPrefixCachePolicy disk_cache_policy; + // Native mmproj vision payload (populated when messages contain images). + std::unique_ptr multimodal; }; // Parse request sampler fields, applying model-card defaults where present. diff --git a/server/src/server/server_main.cpp b/server/src/server/server_main.cpp index 9cb7feafc..464195f5d 100644 --- a/server/src/server/server_main.cpp +++ b/server/src/server/server_main.cpp @@ -70,6 +70,8 @@ static void print_usage(const char * prog) { "\n" "Options:\n" " --draft Draft model for speculative decode\n" + " --mmproj Multimodal projector (mmproj) for native vision\n" + " --no-mmproj-offload Run mmproj on CPU (default: GPU offload)\n" " --port Listen port (default: 8080)\n" " --host Bind address (default: 0.0.0.0)\n" " --max-ctx Max context length (default: 131072)\n" @@ -220,6 +222,7 @@ int main(int argc, char ** argv) { double spark_vram_gib = 0.0; // --spark-vram: total VRAM target in GiB (0=use card) std::string cache_type_k; // explicit --cache-type-k override std::string cache_type_v; // explicit --cache-type-v override + std::string mmproj_path; // --mmproj bool target_device_seen = false; bool target_devices_seen = false; bool fast_rollback_forced_off = false; @@ -252,6 +255,13 @@ int main(int argc, char ** argv) { for (int i = 2; i < argc; i++) { if (std::strcmp(argv[i], "--draft") == 0 && i + 1 < argc) { bargs.draft_path = argv[++i]; + } else if (std::strcmp(argv[i], "--mmproj") == 0 && i + 1 < argc) { + mmproj_path = argv[++i]; + bargs.mmproj_path = mmproj_path.c_str(); + sconfig.mmproj_path = mmproj_path; + sconfig.vision_supported = true; + } else if (std::strcmp(argv[i], "--no-mmproj-offload") == 0) { + bargs.mmproj_use_gpu = false; } else if (std::strcmp(argv[i], "--port") == 0 && i + 1 < argc) { sconfig.port = std::atoi(argv[++i]); } else if (std::strcmp(argv[i], "--host") == 0 && i + 1 < argc) { @@ -598,6 +608,12 @@ int main(int argc, char ** argv) { } } + if (bargs.mmproj_path && bargs.draft_path) { + std::fprintf(stderr, + "[server] mmproj + draft loaded: DFlash for text-only requests, " + "AR decode for image requests\n"); + } + // Ask the factory to resolve model/placement facts and apply its feature // admission policy before any setup work. server_main only maps the // categorized result to the existing process exit convention. @@ -945,6 +961,8 @@ int main(int argc, char ** argv) { std::fprintf(stderr, "[server] │ port = %d\n", sconfig.port); std::fprintf(stderr, "[server] │ model = %s\n", bargs.model_path); std::fprintf(stderr, "[server] │ draft = %s\n", bargs.draft_path ? bargs.draft_path : "(none)"); + std::fprintf(stderr, "[server] │ mmproj = %s\n", + bargs.mmproj_path ? bargs.mmproj_path : "(none)"); std::fprintf(stderr, "[server] │ model_name = %s\n", sconfig.model_name.c_str()); std::fprintf(stderr, "[server] │ max_ctx = %d\n", sconfig.max_ctx); // max_tokens default for requests that omit the field. The request @@ -1081,6 +1099,7 @@ int main(int argc, char ** argv) { sconfig.fa_window = bargs.fa_window; sconfig.ddtree_budget = bargs.ddtree_budget; sconfig.speculative_enabled = bargs.ddtree_mode; + sconfig.vision_supported = !sconfig.mmproj_path.empty(); sconfig.target_sharding = bargs.device.is_layer_split(); // KV type: report the operator's choice if set, else the family default // the backend resolves (the tq3_0 auto policy was removed; laguna uses diff --git a/server/src/vision/vision_encoder.cpp b/server/src/vision/vision_encoder.cpp new file mode 100644 index 000000000..43d545bd4 --- /dev/null +++ b/server/src/vision/vision_encoder.cpp @@ -0,0 +1,139 @@ +// Vision encoder implementation (mtmd wrapper). + +#include "vision_encoder.h" + +#ifdef DFLASH_HAVE_MMPROJ + +#include "mtmd.h" +#include "mtmd-helper.h" +#include "llama.h" + +#include +#include + +namespace dflash::common { + +VisionEncoder::VisionEncoder() = default; +VisionEncoder::~VisionEncoder() = default; + +bool VisionEncoder::init(const char * model_path, + const char * mmproj_path, + bool use_gpu, + int n_threads) { + if (!model_path || !mmproj_path) { + std::fprintf(stderr, "[vision] model_path and mmproj_path are required\n"); + return false; + } + + llama_backend_init(); + + llama_model_params mparams = llama_model_default_params(); + mparams.n_gpu_layers = 0; // vocab/metadata only + mparams.use_mmap = true; + + llama_model * raw_model = llama_model_load_from_file(model_path, mparams); + if (!raw_model) { + std::fprintf(stderr, "[vision] failed to load llama_model from %s\n", model_path); + return false; + } + model_.reset(raw_model); + + mtmd_context_params cparams = mtmd_context_params_default(); + cparams.use_gpu = use_gpu; + cparams.n_threads = (n_threads > 0) ? n_threads : 4; + cparams.warmup = false; + if (const char * s = std::getenv("IMAGE_MIN_TOKENS")) { + const int v = std::atoi(s); + if (v > 0) cparams.image_min_tokens = v; + } + if (const char * s = std::getenv("IMAGE_MAX_TOKENS")) { + const int v = std::atoi(s); + if (v > 0) cparams.image_max_tokens = v; + } + + mtmd_context * raw_ctx = mtmd_init_from_file(mmproj_path, model_.get(), cparams); + if (!raw_ctx) { + std::fprintf(stderr, "[vision] failed to load mmproj from %s\n", mmproj_path); + model_.reset(); + return false; + } + ctx_.reset(raw_ctx); + + std::fprintf(stderr, "[vision] loaded mmproj %s (gpu=%s threads=%d)\n", + mmproj_path, use_gpu ? "on" : "off", cparams.n_threads); + return true; +} + +mtmd_input_chunks * VisionEncoder::tokenize( + const std::string & marked_text, + const std::vector & images) const { + if (!ctx_) return nullptr; + + std::vector bitmap_wrappers; + bitmap_wrappers.reserve(images.size()); + std::vector bitmap_ptrs; + bitmap_ptrs.reserve(images.size()); + + for (const auto & img : images) { + mtmd_bitmap * bmp = mtmd_helper_bitmap_init_from_buf( + ctx_.get(), img.bytes.data(), img.bytes.size()); + if (!bmp) { + std::fprintf(stderr, "[vision] failed to decode image bytes\n"); + return nullptr; + } + bitmap_wrappers.emplace_back(bmp); + bitmap_ptrs.push_back(bitmap_wrappers.back().ptr.get()); + } + + mtmd_input_chunks * chunks = mtmd_input_chunks_init(); + if (!chunks) return nullptr; + + mtmd_input_text text{}; + text.text = marked_text.c_str(); + text.add_special = false; + text.parse_special = true; + + const int32_t rc = mtmd_tokenize(ctx_.get(), chunks, &text, + bitmap_ptrs.data(), bitmap_ptrs.size()); + if (rc != 0) { + std::fprintf(stderr, "[vision] mtmd_tokenize failed rc=%d\n", rc); + mtmd_input_chunks_free(chunks); + return nullptr; + } + return chunks; +} + +bool VisionEncoder::encode_chunk(const mtmd_input_chunk * chunk) { + if (!ctx_ || !chunk) return false; + const int32_t rc = mtmd_encode_chunk(ctx_.get(), chunk); + if (rc != 0) { + std::fprintf(stderr, "[vision] mtmd_encode_chunk failed rc=%d\n", rc); + return false; + } + return true; +} + +float * VisionEncoder::output_embeddings() const { + return ctx_ ? mtmd_get_output_embd(ctx_.get()) : nullptr; +} + +bool VisionEncoder::uses_mrope() const { + return ctx_ && mtmd_decode_use_mrope(ctx_.get()); +} + +bool VisionEncoder::uses_non_causal(const mtmd_input_chunk * chunk) const { + return ctx_ && mtmd_decode_use_non_causal(ctx_.get(), chunk); +} + +void VisionEncoder::get_image_decoder_pos(const mtmd_image_tokens * image_tokens, + mtmd_decoder_pos * out_pos, + size_t n_tokens) const { + if (!image_tokens || !out_pos) return; + for (size_t i = 0; i < n_tokens; i++) { + out_pos[i] = mtmd_image_tokens_get_decoder_pos(image_tokens, i); + } +} + +} // namespace dflash::common + +#endif // DFLASH_HAVE_MMPROJ diff --git a/server/src/vision/vision_encoder.h b/server/src/vision/vision_encoder.h new file mode 100644 index 000000000..7d0cfdcc6 --- /dev/null +++ b/server/src/vision/vision_encoder.h @@ -0,0 +1,80 @@ +// Vision encoder wrapping mtmd for native mmproj inference. + +#pragma once + +#include "common/vision_types.h" + +#include +#include +#include +#include + +#ifdef DFLASH_HAVE_MMPROJ +#include "llama.h" +#include "mtmd.h" +#endif + +namespace dflash::common { + +#ifdef DFLASH_HAVE_MMPROJ + +class VisionEncoder { +public: + VisionEncoder(); + ~VisionEncoder(); + + VisionEncoder(const VisionEncoder &) = delete; + VisionEncoder & operator=(const VisionEncoder &) = delete; + + // Load mmproj + a CPU-only llama_model (vocab/metadata) for tokenization. + bool init(const char * model_path, + const char * mmproj_path, + bool use_gpu, + int n_threads); + + bool ready() const { return ctx_ != nullptr; } + + // Tokenize marked_text + raw image bytes into mtmd chunks. Caller owns + // the returned pointer and must free with mtmd_input_chunks_free(). + mtmd_input_chunks * tokenize(const std::string & marked_text, + const std::vector & images) const; + + // Run the vision projector for an image/audio chunk. + bool encode_chunk(const mtmd_input_chunk * chunk); + + // Embeddings from the last encode_chunk() call (not owned). + float * output_embeddings() const; + + bool uses_mrope() const; + bool uses_non_causal(const mtmd_input_chunk * chunk) const; + void get_image_decoder_pos(const mtmd_image_tokens * image_tokens, + mtmd_decoder_pos * out_pos, + size_t n_tokens) const; + +private: + struct LlamaModelDeleter { + void operator()(llama_model * m) const { + if (m) llama_model_free(m); + } + }; + struct MtmdContextDeleter { + void operator()(mtmd_context * c) const { + if (c) mtmd_free(c); + } + }; + + std::unique_ptr model_; + std::unique_ptr ctx_; +}; + +#else // !DFLASH_HAVE_MMPROJ + +class VisionEncoder { +public: + bool init(const char *, const char *, bool, int) { return false; } + bool ready() const { return false; } +}; + +#endif // DFLASH_HAVE_MMPROJ + +} // namespace dflash::common diff --git a/server/src/vision/vision_input.cpp b/server/src/vision/vision_input.cpp new file mode 100644 index 000000000..ae05eb519 --- /dev/null +++ b/server/src/vision/vision_input.cpp @@ -0,0 +1,176 @@ +// Vision input parsing implementation. + +#include "vision_input.h" + +#ifdef DFLASH_HAVE_MMPROJ +#include "mtmd.h" +#endif + +#include +#include + +namespace dflash::common { + +namespace { + +static const char * kBase64Chars = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +static bool is_base64(unsigned char c) { + return (std::isalnum(c) != 0) || (c == '+') || (c == '/'); +} + +static void append_image_marker(std::string & out) { +#ifdef DFLASH_HAVE_MMPROJ + out += mtmd_default_marker(); +#else + out += "<__media__>"; +#endif +} + +static bool part_is_image_type(const std::string & type) { + return type == "image_url" || type == "input_image" || type == "image"; +} + +static std::vector decode_image_url_object(const json & image_url) { + if (!image_url.is_object()) { + throw std::runtime_error("image_url must be an object"); + } + const std::string url = image_url.value("url", ""); + if (url.empty()) { + throw std::runtime_error("image_url.url is required"); + } + return decode_image_data_url(url); +} + +static void append_part_text(std::string & out, const json & part) { + const std::string type = part.value("type", ""); + if (type == "text" || type == "input_text" || type == "output_text") { + out += part.value("text", ""); + return; + } + if (part_is_image_type(type)) { + append_image_marker(out); + return; + } +} + +static void process_content_array(MultimodalPrompt & mm, const json & content) { + if (!content.is_array()) return; + for (const auto & part : content) { + if (!part.is_object()) continue; + const std::string type = part.value("type", ""); + if (part_is_image_type(type)) { + DecodedImage img; + if (type == "input_image") { + const std::string source = part.value("source", ""); + if (source == "base64" || part.contains("data")) { + const std::string data = part.value("data", ""); + if (data.empty()) { + throw std::runtime_error("input_image data is empty"); + } + img.bytes = base64_decode(data); + } else if (part.contains("image_url")) { + img.bytes = decode_image_url_object(part["image_url"]); + } else { + throw std::runtime_error("unsupported input_image source"); + } + } else { + img.bytes = decode_image_url_object(part.value("image_url", json::object())); + } + if (img.bytes.empty()) { + throw std::runtime_error("decoded image is empty"); + } + mm.images.push_back(std::move(img)); + append_image_marker(mm.marked_text); + continue; + } + append_part_text(mm.marked_text, part); + } +} + +} // namespace + +std::vector base64_decode(const std::string & encoded_string) { + const int in_len = (int)encoded_string.size(); + int i = 0; + int in_ = 0; + unsigned char char_array_4[4], char_array_3[3]; + std::vector ret; + ret.reserve((size_t)in_len * 3 / 4); + + while (in_len - in_ > 0 && encoded_string[in_] != '=' && is_base64(encoded_string[in_])) { + char_array_4[i++] = (unsigned char)encoded_string[in_++]; + if (i == 4) { + for (i = 0; i < 4; i++) { + const char * p = std::strchr(kBase64Chars, char_array_4[i]); + if (!p) throw std::runtime_error("invalid base64"); + char_array_4[i] = (unsigned char)(p - kBase64Chars); + } + char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + for (i = 0; i < 3; i++) ret.push_back(char_array_3[i]); + i = 0; + } + } + + if (i) { + for (int j = i; j < 4; j++) char_array_4[j] = 0; + for (int j = 0; j < 4; j++) { + const char * p = std::strchr(kBase64Chars, char_array_4[j]); + if (!p) throw std::runtime_error("invalid base64"); + char_array_4[j] = (unsigned char)(p - kBase64Chars); + } + char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + for (int j = 0; j < i - 1; j++) ret.push_back(char_array_3[j]); + } + return ret; +} + +std::vector decode_image_data_url(const std::string & url) { + const auto comma = url.find(','); + if (comma == std::string::npos) { + throw std::runtime_error("invalid image data URL"); + } + const std::string header = url.substr(0, comma); + if (header.rfind("data:image/", 0) != 0) { + throw std::runtime_error("image url must be data:image/...;base64,..."); + } + if (header.size() < 7 || header.substr(header.size() - 7) != ";base64") { + throw std::runtime_error("image url must be base64 encoded"); + } + return base64_decode(url.substr(comma + 1)); +} + +MultimodalPrompt extract_multimodal_from_messages(const json & messages) { + MultimodalPrompt mm; + if (!messages.is_array()) return mm; + + for (const auto & m : messages) { + if (!m.is_object()) continue; + if (m.contains("content") && m["content"].is_string()) { + mm.marked_text += m["content"].get(); + } else if (m.contains("content") && m["content"].is_array()) { + process_content_array(mm, m["content"]); + } + } + return mm; +} + +bool messages_contain_images(const json & messages) { + if (!messages.is_array()) return false; + for (const auto & m : messages) { + if (!m.is_object() || !m.contains("content") || !m["content"].is_array()) continue; + for (const auto & part : m["content"]) { + if (!part.is_object()) continue; + const std::string type = part.value("type", ""); + if (part_is_image_type(type)) return true; + } + } + return false; +} + +} // namespace dflash::common diff --git a/server/src/vision/vision_input.h b/server/src/vision/vision_input.h new file mode 100644 index 000000000..b31bc755b --- /dev/null +++ b/server/src/vision/vision_input.h @@ -0,0 +1,34 @@ +// Vision input parsing — base64 decode and multimodal extraction from API +// messages. Does not depend on mtmd; safe to compile without DFLASH_HAVE_MMPROJ. + +#pragma once + +#include "common/vision_types.h" + +#include +#include +#include +#include + +namespace dflash::common { + +using json = nlohmann::json; + +// Decode a base64 string into raw bytes. Throws std::runtime_error on +// invalid input. +std::vector base64_decode(const std::string & encoded); + +// Decode a data:image/...;base64,... URL. Throws on unsupported schemes. +std::vector decode_image_data_url(const std::string & url); + +// Walk an OpenAI-style messages array, decode image_url / input_image parts, +// and build a MultimodalPrompt whose marked_text concatenates text parts with +// mtmd_default_marker() inserted for each image (llama-server-common order). +// When DFLASH_HAVE_MMPROJ is unset, markers are still inserted but callers +// must reject image requests without a loaded mmproj. +MultimodalPrompt extract_multimodal_from_messages(const json & messages); + +// Returns true when `messages` contains at least one image part. +bool messages_contain_images(const json & messages); + +} // namespace dflash::common From d451dc2fee6c3531d8bd513d2c2049aa2d202a6f Mon Sep 17 00:00:00 2001 From: David Roth Date: Thu, 9 Jul 2026 00:38:55 -0500 Subject: [PATCH 02/10] fix(vision): chunk multimodal text prefill to avoid CUDA OOM Agent payloads (38+ tools) tokenize into a single large mtmd text chunk. Prefilling it in one graph build reserved ~8.7GB VRAM and failed on dual-GPU deploys. Sub-chunk text segments with DFLASH27B_PREFILL_UBATCH (same as text prefill) and release scratch buffers before multimodal prefill starts. --- server/src/qwen35/qwen35_backend.cpp | 58 +++++++++++++++++++--------- 1 file changed, 40 insertions(+), 18 deletions(-) diff --git a/server/src/qwen35/qwen35_backend.cpp b/server/src/qwen35/qwen35_backend.cpp index ca1a29900..0071f0ffd 100644 --- a/server/src/qwen35/qwen35_backend.cpp +++ b/server/src/qwen35/qwen35_backend.cpp @@ -837,6 +837,9 @@ GenerateResult Qwen35Backend::generate_impl(const GenerateRequest & req, "vision not configured"); return result; } + // Free oversized gallocr/BSA scratch from prior text-only requests before + // multimodal prefill reserves a fresh graph (avoids CUDA OOM on agent payloads). + release_scratch(); committed = do_prefill_multimodal(*req.multimodal, out_io, req.snap_pos, req.snap_slot); } else { @@ -1432,6 +1435,11 @@ int Qwen35Backend::do_prefill_multimodal(MultimodalPrompt & mm, return -1; } + int prefill_ubatch = 512; + if (const char * s = std::getenv("DFLASH27B_PREFILL_UBATCH")) { + prefill_ubatch = std::max(1, std::atoi(s)); + } + std::vector embed_buf; int committed = kv_offset; @@ -1448,29 +1456,43 @@ int Qwen35Backend::do_prefill_multimodal(MultimodalPrompt & mm, const int n_tokens = (int)n_tokens_sz; if (n_tokens <= 0) continue; + if (n_tokens > prefill_ubatch) { + std::fprintf(stderr, + "[vision] chunking text mtmd_chunk=%zu tokens=%d ubatch=%d\n", + ci, n_tokens, prefill_ubatch); + } + std::vector tokens(n_tokens); for (int i = 0; i < n_tokens; i++) tokens[(size_t)i] = (int32_t)toks[i]; - embed_buf.resize((size_t)hidden * (size_t)n_tokens); - if (!w_.embedder.embed(tokens.data(), n_tokens, embed_buf.data())) { - return -1; - } + for (int start = 0; start < n_tokens; ) { + const int sub_n = std::min(prefill_ubatch, n_tokens - start); + const bool is_last_sub = (start + sub_n >= n_tokens); + const bool sub_last_logits_only = !(is_last_chunk && is_last_sub); - std::vector pos_buf((size_t)4 * (size_t)n_tokens, 0); - for (int i = 0; i < n_tokens; i++) { - const int p = kv_pos + i; - pos_buf[4 * i + 0] = p; - pos_buf[4 * i + 1] = p; - pos_buf[4 * i + 2] = p; - pos_buf[4 * i + 3] = 0; - } + embed_buf.resize((size_t)hidden * (size_t)sub_n); + if (!w_.embedder.embed(tokens.data() + start, sub_n, + embed_buf.data())) { + return -1; + } - const bool with_mask = (cfg_.kq_stride_pad > KQ_MASK_PAD) || (n_tokens > 1); - if (!do_prefill_embed_chunk(kv_pos, n_tokens, embed_buf.data(), hidden, - pos_buf, with_mask, - /*last_token_logits_only=*/!is_last_chunk, - /*non_causal_within_chunk=*/false)) { - return -1; + std::vector pos_buf((size_t)4 * (size_t)sub_n, 0); + for (int i = 0; i < sub_n; i++) { + const int p = kv_pos + start + i; + pos_buf[4 * i + 0] = p; + pos_buf[4 * i + 1] = p; + pos_buf[4 * i + 2] = p; + pos_buf[4 * i + 3] = 0; + } + + const bool with_mask = (cfg_.kq_stride_pad > KQ_MASK_PAD) || (sub_n > 1); + if (!do_prefill_embed_chunk(kv_pos + start, sub_n, embed_buf.data(), + hidden, pos_buf, with_mask, + sub_last_logits_only, + /*non_causal_within_chunk=*/false)) { + return -1; + } + start += sub_n; } committed = kv_pos + n_tokens; From 071fbaf1dc69cb757278dbb608afaf87a058b115 Mon Sep 17 00:00:00 2001 From: David Roth Date: Thu, 9 Jul 2026 11:06:06 -0500 Subject: [PATCH 03/10] Add layer-split multimodal prefill for Qwen35 vision. Wire mmproj through the layer-split adapter and backend so dflash_server can run vision prefill across sharded GPUs with mRoPE/bidirectional masks. --- server/CMakeLists.txt | 1 + server/src/common/attn_masks.h | 20 ++ server/src/common/backend_factory.cpp | 5 + server/src/common/layer_split_backend.cpp | 84 ++++-- server/src/common/layer_split_backend.h | 7 + server/src/qwen35/layer_split_forward.cpp | 49 ++-- server/src/qwen35/layer_split_forward.h | 11 +- .../src/qwen35/qwen35_layer_split_adapter.cpp | 23 ++ .../src/qwen35/qwen35_layer_split_adapter.h | 15 ++ .../src/qwen35/qwen35_layer_split_vision.cpp | 247 ++++++++++++++++++ 10 files changed, 419 insertions(+), 43 deletions(-) create mode 100644 server/src/qwen35/qwen35_layer_split_vision.cpp diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index 45decd074..0acbd0c9f 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -337,6 +337,7 @@ add_library(dflash_common STATIC src/qwen35/qwen35_backend.cpp src/qwen35/qwen35_tensor_parallel.cpp src/qwen35/qwen35_layer_split_adapter.cpp + src/qwen35/qwen35_layer_split_vision.cpp src/qwen35/qwen35_dflash_target.cpp src/qwen35/qwen35_layer_split_dflash_target.cpp src/qwen35/layer_split_daemon_loop.cpp diff --git a/server/src/common/attn_masks.h b/server/src/common/attn_masks.h index ec25ca561..5c808807f 100644 --- a/server/src/common/attn_masks.h +++ b/server/src/common/attn_masks.h @@ -75,4 +75,24 @@ inline void build_tree_mask(const DDTree & tree, int past_length, } } +// Bidirectional mask for vision image chunks (full attention within chunk + +// to all prior KV). Matches Qwen35Backend::build_bidirectional_mask. +inline void build_bidirectional_mask(std::vector & out, + int kv_len, int n_tokens, int kv_pos, + int kq_stride_pad, + int kv_pad_override = 0) { + const int kv_pad = (kv_pad_override > 0) ? kv_pad_override + : align_up(kv_len, kq_stride_pad); + const int q_pad = align_up(n_tokens, KQ_MASK_PAD); + out.assign((size_t)kv_pad * q_pad, F16_NEG_INF); + for (int q = 0; q < n_tokens; q++) { + for (int k = 0; k < kv_pos; k++) { + out[(size_t)q * kv_pad + k] = F16_ZERO; + } + for (int k = kv_pos; k < kv_pos + n_tokens; k++) { + out[(size_t)q * kv_pad + k] = F16_ZERO; + } + } +} + } // namespace dflash::common diff --git a/server/src/common/backend_factory.cpp b/server/src/common/backend_factory.cpp index 0d3633da4..e9d617eba 100644 --- a/server/src/common/backend_factory.cpp +++ b/server/src/common/backend_factory.cpp @@ -242,6 +242,11 @@ std::unique_ptr create_backend( ? std::max(DFLASH27B_DRAFT_BLOCK_SIZE, args.ddtree_budget + 1) : DFLASH27B_DRAFT_BLOCK_SIZE; cfg.run_dflash = args.draft_path != nullptr; + cfg.mmproj_path = args.mmproj_path; + cfg.mmproj_use_gpu = args.mmproj_use_gpu; + if (const char * mt = std::getenv("DFLASH_MMPROJ_THREADS")) { + cfg.mmproj_threads = std::max(1, std::atoi(mt)); + } auto adapter = std::make_unique(cfg); auto backend = std::make_unique(std::move(adapter)); diff --git a/server/src/common/layer_split_backend.cpp b/server/src/common/layer_split_backend.cpp index b2c0ebbde..097bad46e 100644 --- a/server/src/common/layer_split_backend.cpp +++ b/server/src/common/layer_split_backend.cpp @@ -56,7 +56,11 @@ GenerateResult LayerSplitBackend::run_from_state(const GenerateRequest & req, } DaemonIO out_io = io.with_token_callback(req.on_token); - if (base_pos + (int)req.prompt.size() + req.n_gen + 1 > adapter_->max_context()) { + const bool use_multimodal = + req.multimodal && !req.multimodal->images.empty(); + + if (!use_multimodal && + base_pos + (int)req.prompt.size() + req.n_gen + 1 > adapter_->max_context()) { result.fail(GenerateErrorCode::ContextOverflow); return result; } @@ -69,39 +73,65 @@ GenerateResult LayerSplitBackend::run_from_state(const GenerateRequest & req, adapter_->begin_request(req); if (reset_state) adapter_->reset_request_state(); - const int prompt_len = (int)req.prompt.size(); - const int adapter_chunk = adapter_->prefill_chunk_tokens(); - int last_tok = (base_pos > 0 && prompt_len == 0) + int last_tok = (base_pos > 0 && !use_multimodal && req.prompt.empty()) ? adapter_->current_last_token() : -1; - int consumed = 0; auto t_prefill_start = std::chrono::steady_clock::now(); - while (consumed < prompt_len) { - int n_tokens = prompt_len - consumed; - if (adapter_chunk > 0 && n_tokens > adapter_chunk) { - n_tokens = adapter_chunk; - } - if (req.snap_pos >= 0 && req.snap_slot >= 0 && - req.snap_pos > base_pos + consumed && - req.snap_pos < base_pos + consumed + n_tokens) { - n_tokens = req.snap_pos - (base_pos + consumed); + + if (use_multimodal) { + if (!adapter_->supports_multimodal()) { + result.fail(GenerateErrorCode::AdapterUnavailable, + "vision not configured"); + return result; } - std::vector chunk(req.prompt.begin() + consumed, - req.prompt.begin() + consumed + n_tokens); - if (!adapter_->prefill(chunk, base_pos + consumed, last_tok)) { + MultimodalPrompt mm = *req.multimodal; + const int committed = adapter_->prefill_multimodal(mm, last_tok); + if (committed < 0) { result.fail(GenerateErrorCode::PrefillFailed); return result; } - consumed += n_tokens; + if (committed + req.n_gen + 1 > adapter_->max_context()) { + result.fail(GenerateErrorCode::ContextOverflow); + return result; + } if (req.snap_pos >= 0 && req.snap_slot >= 0 && - base_pos + consumed == req.snap_pos) { - if (adapter_->snapshot_save(req.snap_slot)) { - std::printf("[snap] inline slot=%d cur_pos=%d\n", - req.snap_slot, req.snap_pos); - std::fflush(stdout); + adapter_->snapshot_save(req.snap_slot)) { + std::printf("[snap] inline slot=%d cur_pos=%d\n", + req.snap_slot, req.snap_pos); + std::fflush(stdout); + } + } else { + const int prompt_len = (int)req.prompt.size(); + const int adapter_chunk = adapter_->prefill_chunk_tokens(); + int consumed = 0; + while (consumed < prompt_len) { + int n_tokens = prompt_len - consumed; + if (adapter_chunk > 0 && n_tokens > adapter_chunk) { + n_tokens = adapter_chunk; + } + if (req.snap_pos >= 0 && req.snap_slot >= 0 && + req.snap_pos > base_pos + consumed && + req.snap_pos < base_pos + consumed + n_tokens) { + n_tokens = req.snap_pos - (base_pos + consumed); + } + std::vector chunk(req.prompt.begin() + consumed, + req.prompt.begin() + consumed + n_tokens); + if (!adapter_->prefill(chunk, base_pos + consumed, last_tok)) { + result.fail(GenerateErrorCode::PrefillFailed); + return result; + } + consumed += n_tokens; + if (req.snap_pos >= 0 && req.snap_slot >= 0 && + base_pos + consumed == req.snap_pos) { + if (adapter_->snapshot_save(req.snap_slot)) { + std::printf("[snap] inline slot=%d cur_pos=%d\n", + req.snap_slot, req.snap_pos); + std::fflush(stdout); + } } } } + result.prefill_s = std::chrono::duration( std::chrono::steady_clock::now() - t_prefill_start).count(); @@ -111,13 +141,17 @@ GenerateResult LayerSplitBackend::run_from_state(const GenerateRequest & req, return result; } auto t_decode_start = std::chrono::steady_clock::now(); - const bool use_dflash = !req.force_ar_decode && adapter_->can_dflash_decode(); + const int committed_pos = use_multimodal + ? adapter_->current_cur_pos() + : base_pos + (int)req.prompt.size(); + const bool force_ar = req.force_ar_decode || use_multimodal; + const bool use_dflash = !force_ar && adapter_->can_dflash_decode(); if (use_dflash) result.spec_decode_ran = true; float dflash_accept_rate = 0.0f; const bool ok = use_dflash ? adapter_->decode_dflash(req.prompt, base_pos, last_tok, req.n_gen, result.tokens, out_io, dflash_accept_rate) - : adapter_->decode_ar(last_tok, base_pos + (int)req.prompt.size(), req.n_gen, + : adapter_->decode_ar(last_tok, committed_pos, req.n_gen, history_prefix, result.tokens, out_io); if (use_dflash) result.accept_rate = dflash_accept_rate; diff --git a/server/src/common/layer_split_backend.h b/server/src/common/layer_split_backend.h index 390870164..9869a28b6 100644 --- a/server/src/common/layer_split_backend.h +++ b/server/src/common/layer_split_backend.h @@ -28,6 +28,12 @@ class LayerSplitAdapter { virtual int prefill_chunk_tokens() const { return 0; } virtual bool prefill(const std::vector & prompt, int base_pos, int & last_tok) = 0; + virtual bool supports_multimodal() const { return false; } + virtual int prefill_multimodal(MultimodalPrompt & mm, int & last_tok) { + (void)mm; + (void)last_tok; + return -1; + } // history_prefix is the full original request prompt (not the delta // prefill after a prefix-cache restore); it seeds sampler penalty history. virtual bool decode_ar(int last_tok, int committed, int n_gen, @@ -77,6 +83,7 @@ class LayerSplitAdapter { return false; } virtual int current_last_token() const { return -1; } + virtual int current_cur_pos() const { return 0; } virtual void shutdown() = 0; }; diff --git a/server/src/qwen35/layer_split_forward.cpp b/server/src/qwen35/layer_split_forward.cpp index a66383cc9..37a7078b1 100644 --- a/server/src/qwen35/layer_split_forward.cpp +++ b/server/src/qwen35/layer_split_forward.cpp @@ -425,7 +425,8 @@ bool run_qwen35_layer_split_layers_from_activation( bool capture_ssm_intermediates, Qwen35SplitCaptureStats * capture_stats, bool kvflash_preallocated = false, - const Qwen35SplitTreeInputs * tree_inputs = nullptr) { + const Qwen35SplitTreeInputs * tree_inputs = nullptr, + const LayerSplitAttnPrefillOpts * attn_opts = nullptr) { if (shards.empty() || !acts.a || !acts.b || n_tokens_total <= 0) return false; if (kvflash && fa_window > 0) { std::fprintf(stderr, @@ -509,16 +510,23 @@ bool run_qwen35_layer_split_layers_from_activation( return false; } if (is_attn && shard->layer_graph.positions) { - pos_buf.assign((size_t)4 * n, 0); - for (int i = 0; i < n; i++) { - const int p = kv_start + i; - pos_buf[0 * n + i] = p; - pos_buf[1 * n + i] = p; - pos_buf[2 * n + i] = p; - pos_buf[3 * n + i] = 0; + if (attn_opts && attn_opts->positions) { + const int32_t * src = attn_opts->positions + (size_t)4 * (size_t)start; + pos_buf.assign(src, src + (size_t)4 * (size_t)n); + ggml_backend_tensor_set(shard->layer_graph.positions, pos_buf.data(), 0, + sizeof(int32_t) * pos_buf.size()); + } else { + pos_buf.assign((size_t)4 * n, 0); + for (int i = 0; i < n; i++) { + const int p = kv_start + i; + pos_buf[0 * n + i] = p; + pos_buf[1 * n + i] = p; + pos_buf[2 * n + i] = p; + pos_buf[3 * n + i] = 0; + } + ggml_backend_tensor_set(shard->layer_graph.positions, pos_buf.data(), 0, + sizeof(int32_t) * pos_buf.size()); } - ggml_backend_tensor_set(shard->layer_graph.positions, pos_buf.data(), 0, - sizeof(int32_t) * pos_buf.size()); } if (is_attn && kvflash) { if (!fill_qwen35_kvflash_inputs( @@ -527,12 +535,17 @@ bool run_qwen35_layer_split_layers_from_activation( return false; } } else if (is_attn && with_mask && shard->layer_graph.attn_mask) { - const int win_start_l = (fa_window > 0 && kv_start > fa_window) - ? (kv_start - fa_window) : 0; - const int win_len_l = kv_len - win_start_l; const int kv_pad_override = (int)shard->layer_graph.attn_mask->ne[0]; - build_causal_mask(mask_buf, win_len_l, n, kv_start, kq_stride_pad, - win_start_l, kv_pad_override); + if (attn_opts && attn_opts->bidirectional) { + build_bidirectional_mask(mask_buf, kv_len, n, kv_start, + kq_stride_pad, kv_pad_override); + } else { + const int win_start_l = (fa_window > 0 && kv_start > fa_window) + ? (kv_start - fa_window) : 0; + const int win_len_l = kv_len - win_start_l; + build_causal_mask(mask_buf, win_len_l, n, kv_start, kq_stride_pad, + win_start_l, kv_pad_override); + } ggml_backend_tensor_set(shard->layer_graph.attn_mask, mask_buf.data(), 0, sizeof(uint16_t) * mask_buf.size()); } @@ -627,12 +640,14 @@ bool run_qwen35_layer_split_forward_from_activation( KvFlashPager * kvflash, bool kvflash_preallocated, const Qwen35SplitTreeInputs * tree_inputs, - bool capture_ssm_intermediates) { + bool capture_ssm_intermediates, + const LayerSplitAttnPrefillOpts * attn_opts) { if (!run_qwen35_layer_split_layers_from_activation( shards, acts, base_pos, n_tokens_total, ubatch, kq_stride_pad, fa_window, captures_out, nullptr, nullptr, kvflash, capture_ssm_intermediates, - /*capture_stats=*/nullptr, kvflash_preallocated, tree_inputs)) { + /*capture_stats=*/nullptr, kvflash_preallocated, tree_inputs, + attn_opts)) { return false; } diff --git a/server/src/qwen35/layer_split_forward.h b/server/src/qwen35/layer_split_forward.h index c9ddb3b9a..8895755f5 100644 --- a/server/src/qwen35/layer_split_forward.h +++ b/server/src/qwen35/layer_split_forward.h @@ -22,6 +22,14 @@ namespace dflash::common { class KvFlashPager; +// Optional attention overrides for multimodal prefill (mRoPE positions, +// bidirectional image masks). positions uses layer-split layout: +// [dim0*n + i, dim1*n + i, dim2*n + i, dim3*n + i] for n query tokens. +struct LayerSplitAttnPrefillOpts { + const int32_t * positions = nullptr; + bool bidirectional = false; +}; + // Compute argmax(logits) for a slice of the activation tensor via // out_norm + lm_head projection. bool compute_target_split_argmax( @@ -83,7 +91,8 @@ bool run_qwen35_layer_split_forward_from_activation( KvFlashPager * kvflash = nullptr, bool kvflash_preallocated = false, const Qwen35SplitTreeInputs * tree_inputs = nullptr, - bool capture_ssm_intermediates = false); + bool capture_ssm_intermediates = false, + const LayerSplitAttnPrefillOpts * attn_opts = nullptr); bool run_qwen35_layer_split_tree_verify_from_activation( std::vector & shards, diff --git a/server/src/qwen35/qwen35_layer_split_adapter.cpp b/server/src/qwen35/qwen35_layer_split_adapter.cpp index a323e6a93..d6dd09890 100644 --- a/server/src/qwen35/qwen35_layer_split_adapter.cpp +++ b/server/src/qwen35/qwen35_layer_split_adapter.cpp @@ -14,6 +14,7 @@ #include "qwen35/qwen35_layer_split_dflash_target.h" #include "qwen3/qwen3_drafter.h" #include "qwen3/qwen3_kvflash_scorer.h" +#include "vision/vision_encoder.h" #include "kv_quant.h" #include "ggml-cuda.h" @@ -107,6 +108,20 @@ bool Qwen35LayerSplitAdapter::init() { if (cfg_.draft_path && cfg_.run_dflash && !load_draft()) { return false; } + +#ifdef DFLASH_HAVE_MMPROJ + if (cfg_.mmproj_path && cfg_.mmproj_path[0]) { + vision_ = std::make_unique(); + if (!vision_->init(cfg_.target_path, cfg_.mmproj_path, + cfg_.mmproj_use_gpu, cfg_.mmproj_threads)) { + std::fprintf(stderr, "[target-split][vision] mmproj init failed\n"); + return false; + } + std::fprintf(stderr, "[target-split][vision] mmproj loaded: %s\n", + cfg_.mmproj_path); + } +#endif + prefix_snapshots_.resize(PREFIX_SLOTS); for (auto & slot : prefix_snapshots_) { slot.resize(shards_.size()); @@ -1274,6 +1289,11 @@ int Qwen35LayerSplitAdapter::current_last_token() const { return shards_.front().cache.last_tok; } +int Qwen35LayerSplitAdapter::current_cur_pos() const { + if (shards_.empty()) return 0; + return shards_.front().cache.cur_pos; +} + bool Qwen35LayerSplitAdapter::decode_ar( int last_tok, int committed, int n_gen, const std::vector & history_prefix, @@ -1419,6 +1439,9 @@ DFlashTarget * Qwen35LayerSplitAdapter::dflash_target() { void Qwen35LayerSplitAdapter::shutdown() { dflash_target_.reset(); +#ifdef DFLASH_HAVE_MMPROJ + vision_.reset(); +#endif free_drafter(); for (int slot = 0; slot < (int)prefix_snapshots_.size(); ++slot) { snapshot_free(slot); diff --git a/server/src/qwen35/qwen35_layer_split_adapter.h b/server/src/qwen35/qwen35_layer_split_adapter.h index 7f5e7b129..fe5ac4f3b 100644 --- a/server/src/qwen35/qwen35_layer_split_adapter.h +++ b/server/src/qwen35/qwen35_layer_split_adapter.h @@ -24,6 +24,10 @@ #include #include +namespace dflash::common { +class VisionEncoder; +} + namespace dflash::common { struct Qwen35LayerSplitAdapterConfig { @@ -41,6 +45,9 @@ struct Qwen35LayerSplitAdapterConfig { int max_verify_tokens = DFLASH27B_DRAFT_BLOCK_SIZE; bool run_dflash = false; int draft_swa_window = 0; + const char * mmproj_path = nullptr; + bool mmproj_use_gpu = true; + int mmproj_threads = 4; }; class Qwen35LayerSplitAdapter : public LayerSplitAdapter { @@ -60,6 +67,8 @@ class Qwen35LayerSplitAdapter : public LayerSplitAdapter { int prefill_chunk_tokens() const override; bool prefill(const std::vector & prompt, int base_pos, int & last_tok) override; + bool supports_multimodal() const override; + int prefill_multimodal(MultimodalPrompt & mm, int & last_tok) override; bool decode_ar(int last_tok, int committed, int n_gen, const std::vector & history_prefix, std::vector & out_tokens, @@ -86,6 +95,7 @@ class Qwen35LayerSplitAdapter : public LayerSplitAdapter { ggml_backend_buffer_t buf, int cur_pos, int32_t last_tok) override; int current_last_token() const override; + int current_cur_pos() const override; bool supports_dflash_spec_decode() const override { return true; } DFlashTarget * dflash_target() override; @@ -114,6 +124,10 @@ class Qwen35LayerSplitAdapter : public LayerSplitAdapter { bool snapshot_draft_features(int slot); void free_draft_feature_snapshot(int slot); bool restore_draft_features(int slot); + bool prefill_activation_chunk(int kv_pos, int n_tokens, const float * embeds, + int hidden, const LayerSplitAttnPrefillOpts * attn_opts, + bool want_logits); + void sync_draft_features_range(int kv_pos, int n_tokens); Qwen35LayerSplitAdapterConfig cfg_; std::vector shards_; @@ -162,6 +176,7 @@ class Qwen35LayerSplitAdapter : public LayerSplitAdapter { std::mt19937_64 sampler_rng_{std::random_device{}()}; std::unique_ptr dflash_target_; std::vector prefill_last_logits_; + std::unique_ptr vision_; }; } // namespace dflash::common diff --git a/server/src/qwen35/qwen35_layer_split_vision.cpp b/server/src/qwen35/qwen35_layer_split_vision.cpp new file mode 100644 index 000000000..aa86c7e49 --- /dev/null +++ b/server/src/qwen35/qwen35_layer_split_vision.cpp @@ -0,0 +1,247 @@ +// Multimodal prefill for Qwen35 layer-split adapter. + +#include "qwen35_layer_split_adapter.h" + +#include "common/dflash_layer_split_runtime.h" +#include "dflash_feature_ring.h" +#include "internal.h" +#include "qwen35/layer_split_forward.h" +#include "vision/vision_encoder.h" + +#include +#include +#include + +namespace dflash::common { + +bool Qwen35LayerSplitAdapter::supports_multimodal() const { +#ifdef DFLASH_HAVE_MMPROJ + return vision_ && vision_->ready(); +#else + return false; +#endif +} + +void Qwen35LayerSplitAdapter::sync_draft_features_range(int kv_pos, int n_tokens) { + if (n_tokens <= 0 || !cfg_.run_dflash) return; + if (remote_draft_.active()) { + // Remote draft sync is handled inside spec-decode; skip here. + return; + } + if (feature_ring_.target_feat && !shards_.empty()) { + const auto & cache = shards_.front().cache; + if (cache.target_feat) { + draft_feature_mirror_sync_range(cache.target_feat, cache.target_feat_cap, + feature_ring_, kv_pos, n_tokens); + } + } +} + +bool Qwen35LayerSplitAdapter::prefill_activation_chunk( + int kv_pos, int n_tokens, const float * embeds, int hidden, + const LayerSplitAttnPrefillOpts * attn_opts, bool want_logits) { + if (shards_.empty() || n_tokens <= 0 || !embeds) return false; + if (use_mixed_target_split()) { + std::fprintf(stderr, "[target-split][vision] mixed target split unsupported\n"); + return false; + } + + int ubatch = cfg_.chunk > 0 ? cfg_.chunk : 512; + if (const char * s = std::getenv("DFLASH27B_PREFILL_UBATCH")) { + ubatch = std::max(1, std::atoi(s)); + } + + ActivationPair acts; + if (!activation_pair_init(acts, shards_.front().backend, hidden, n_tokens, + activation_type_)) { + std::fprintf(stderr, "[target-split][vision] activation alloc failed\n"); + return false; + } + + if (!set_activation_tensor_from_f32( + acts.a, embeds, 0, (size_t)hidden * (size_t)n_tokens)) { + activation_pair_free(acts); + return false; + } + + int last_tok = -1; + std::vector logits; + const bool ok = run_qwen35_layer_split_forward_from_activation( + shards_, acts, kv_pos, n_tokens, ubatch, last_tok, + cfg_.kq_stride_pad, cfg_.fa_window, + /*argmax_out=*/nullptr, + want_logits ? &prefill_last_logits_ : nullptr, + /*captures_out=*/nullptr, + kvflash_active() ? &kvflash_pager_ : nullptr, + /*kvflash_preallocated=*/false, + /*tree_inputs=*/nullptr, + /*capture_ssm_intermediates=*/false, + attn_opts); + activation_pair_free(acts); + if (!ok) return false; + + if (cfg_.run_dflash && !remote_draft_.active()) { + sync_draft_features_range(kv_pos, n_tokens); + } + return true; +} + +int Qwen35LayerSplitAdapter::prefill_multimodal(MultimodalPrompt & mm, + int & last_tok) { +#ifdef DFLASH_HAVE_MMPROJ + if (!vision_ || !vision_->ready()) { + std::fprintf(stderr, "[target-split][vision] encoder not initialized\n"); + return -1; + } + if (shards_.empty()) return -1; + + for (auto & shard : shards_) { + reset_recurrent_state(shard.cache); + } + + mtmd_input_chunks * chunks = vision_->tokenize(mm.marked_text, mm.images); + if (!chunks) return -1; + + struct ChunksGuard { + mtmd_input_chunks * p; + ~ChunksGuard() { if (p) mtmd_input_chunks_free(p); } + } chunks_guard{chunks}; + + const size_t n_chunks = mtmd_input_chunks_size(chunks); + if (n_chunks == 0) { + last_tok = shards_.front().cache.last_tok; + return 0; + } + + const int hidden = shards_.front().weights.n_embd; + int prefill_ubatch = 512; + if (const char * s = std::getenv("DFLASH27B_PREFILL_UBATCH")) { + prefill_ubatch = std::max(1, std::atoi(s)); + } + + std::vector embed_buf; + int committed = 0; + + for (size_t ci = 0; ci < n_chunks; ci++) { + const mtmd_input_chunk * chunk = mtmd_input_chunks_get(chunks, ci); + const auto chunk_type = mtmd_input_chunk_get_type(chunk); + const bool is_last_chunk = (ci + 1 == n_chunks); + const int kv_pos = committed; + + if (chunk_type == MTMD_INPUT_CHUNK_TYPE_TEXT) { + size_t n_tokens_sz = 0; + const llama_token * toks = + mtmd_input_chunk_get_tokens_text(chunk, &n_tokens_sz); + const int n_tokens = (int)n_tokens_sz; + if (n_tokens <= 0) continue; + + if (n_tokens > prefill_ubatch) { + std::fprintf(stderr, + "[target-split][vision] chunking text mtmd_chunk=%zu tokens=%d ubatch=%d\n", + ci, n_tokens, prefill_ubatch); + } + + std::vector tokens((size_t)n_tokens); + for (int i = 0; i < n_tokens; i++) { + tokens[(size_t)i] = (int32_t)toks[i]; + } + + for (int start = 0; start < n_tokens; ) { + const int sub_n = std::min(prefill_ubatch, n_tokens - start); + const bool is_last_sub = (start + sub_n >= n_tokens); + const bool want_logits = is_last_chunk && is_last_sub; + + embed_buf.resize((size_t)hidden * (size_t)sub_n); + if (!shards_.front().weights.embedder.embed( + tokens.data() + start, sub_n, embed_buf.data())) { + return -1; + } + + std::vector pos_buf((size_t)4 * (size_t)sub_n, 0); + for (int i = 0; i < sub_n; i++) { + const int p = kv_pos + start + i; + pos_buf[4 * i + 0] = p; + pos_buf[4 * i + 1] = p; + pos_buf[4 * i + 2] = p; + pos_buf[4 * i + 3] = 0; + } + LayerSplitAttnPrefillOpts attn; + attn.positions = pos_buf.data(); + + if (!prefill_activation_chunk(kv_pos + start, sub_n, + embed_buf.data(), hidden, + &attn, want_logits)) { + return -1; + } + start += sub_n; + } + committed = kv_pos + n_tokens; + } else if (chunk_type == MTMD_INPUT_CHUNK_TYPE_IMAGE || + chunk_type == MTMD_INPUT_CHUNK_TYPE_AUDIO) { + const int n_tokens = (int)mtmd_input_chunk_get_n_tokens(chunk); + if (n_tokens <= 0) continue; + + if (!vision_->encode_chunk(chunk)) return -1; + float * embd = vision_->output_embeddings(); + if (!embd) return -1; + + std::vector pos_buf; + LayerSplitAttnPrefillOpts attn; + if (vision_->uses_mrope() && + chunk_type == MTMD_INPUT_CHUNK_TYPE_IMAGE) { + const auto * image_tokens = + mtmd_input_chunk_get_tokens_image(chunk); + if (!image_tokens) return -1; + std::vector rel_pos((size_t)n_tokens); + vision_->get_image_decoder_pos(image_tokens, rel_pos.data(), + (size_t)n_tokens); + pos_buf.resize((size_t)4 * (size_t)n_tokens, 0); + for (int i = 0; i < n_tokens; i++) { + pos_buf[4 * i + 0] = + kv_pos + (int)rel_pos[(size_t)i].t; + pos_buf[4 * i + 1] = + kv_pos + (int)rel_pos[(size_t)i].y; + pos_buf[4 * i + 2] = + kv_pos + (int)rel_pos[(size_t)i].x; + pos_buf[4 * i + 3] = 0; + } + attn.positions = pos_buf.data(); + } else { + pos_buf.resize((size_t)4 * (size_t)n_tokens, 0); + for (int i = 0; i < n_tokens; i++) { + const int p = kv_pos + i; + pos_buf[4 * i + 0] = p; + pos_buf[4 * i + 1] = p; + pos_buf[4 * i + 2] = p; + pos_buf[4 * i + 3] = 0; + } + attn.positions = pos_buf.data(); + } + attn.bidirectional = vision_->uses_non_causal(chunk); + + if (!prefill_activation_chunk(kv_pos, n_tokens, embd, hidden, &attn, + /*want_logits=*/is_last_chunk)) { + return -1; + } + committed = kv_pos + (int)mtmd_input_chunk_get_n_pos(chunk); + } else { + std::fprintf(stderr, "[target-split][vision] unsupported mtmd chunk\n"); + return -1; + } + + for (auto & shard : shards_) { + shard.cache.cur_pos = committed; + } + } + + last_tok = shards_.front().cache.last_tok; + return committed; +#else + (void)mm; + (void)last_tok; + std::fprintf(stderr, "[target-split][vision] built without DFLASH_HAVE_MMPROJ\n"); + return -1; +#endif +} + +} // namespace dflash::common From e30d26dc7faf75ec17cc0bd0f9e79353c34718e8 Mon Sep 17 00:00:00 2001 From: David Roth Date: Thu, 9 Jul 2026 11:07:16 -0500 Subject: [PATCH 04/10] Fix layer-split vision build: include attn opts type, dedupe mask helper. Forward-declare LayerSplitAttnPrefillOpts via layer_split_forward.h and use the shared build_bidirectional_mask from attn_masks.h in qwen35_backend. --- server/src/qwen35/qwen35_backend.cpp | 21 ------------------- .../src/qwen35/qwen35_layer_split_adapter.h | 1 + 2 files changed, 1 insertion(+), 21 deletions(-) diff --git a/server/src/qwen35/qwen35_backend.cpp b/server/src/qwen35/qwen35_backend.cpp index 0071f0ffd..83b69eac5 100644 --- a/server/src/qwen35/qwen35_backend.cpp +++ b/server/src/qwen35/qwen35_backend.cpp @@ -1325,27 +1325,6 @@ int Qwen35Backend::do_prefill(const std::vector & tokens, #ifdef DFLASH_HAVE_MMPROJ -namespace { - -void build_bidirectional_mask(std::vector & out, - int kv_len, int n_tokens, int kv_pos, - int kq_stride_pad, int kv_pad_override = 0) { - const int kv_pad = (kv_pad_override > 0) ? kv_pad_override - : align_up(kv_len, kq_stride_pad); - const int q_pad = align_up(n_tokens, KQ_MASK_PAD); - out.assign((size_t)kv_pad * q_pad, F16_NEG_INF); - for (int q = 0; q < n_tokens; q++) { - for (int k = 0; k < kv_pos; k++) { - out[(size_t)q * kv_pad + k] = F16_ZERO; - } - for (int k = kv_pos; k < kv_pos + n_tokens; k++) { - out[(size_t)q * kv_pad + k] = F16_ZERO; - } - } -} - -} // namespace - bool Qwen35Backend::do_prefill_embed_chunk(int kv_pos, int n_tokens, const float * embeds, int hidden, const std::vector & pos_buf, diff --git a/server/src/qwen35/qwen35_layer_split_adapter.h b/server/src/qwen35/qwen35_layer_split_adapter.h index fe5ac4f3b..a9af3bd6f 100644 --- a/server/src/qwen35/qwen35_layer_split_adapter.h +++ b/server/src/qwen35/qwen35_layer_split_adapter.h @@ -14,6 +14,7 @@ #include "placement/remote_target_shard_config.h" #include "qwen3/qwen3_drafter.h" #include "qwen35_target_shard_ipc.h" +#include "qwen35/layer_split_forward.h" #include "step_graph.h" #include "internal.h" From 32abfd11deba1432e4c38ff734712182b7719b1b Mon Sep 17 00:00:00 2001 From: David Roth Date: Mon, 13 Jul 2026 03:37:40 -0500 Subject: [PATCH 05/10] fix: expose layer-split mmproj via supports_multimodal() GENERATE_MULTIMODAL checked ModelBackend::supports_multimodal(), but LayerSplitBackend never delegated to the adapter, so vision failed with vision_not_configured even after mmproj loaded successfully. --- server/src/common/layer_split_backend.cpp | 4 ++++ server/src/common/layer_split_backend.h | 2 ++ 2 files changed, 6 insertions(+) diff --git a/server/src/common/layer_split_backend.cpp b/server/src/common/layer_split_backend.cpp index 097bad46e..4e819e628 100644 --- a/server/src/common/layer_split_backend.cpp +++ b/server/src/common/layer_split_backend.cpp @@ -25,6 +25,10 @@ bool LayerSplitBackend::init() { return adapter_->init(); } +bool LayerSplitBackend::supports_multimodal() const { + return adapter_ && adapter_->supports_multimodal(); +} + void LayerSplitBackend::print_ready_banner() const { std::printf("[daemon] ready\n"); std::fflush(stdout); diff --git a/server/src/common/layer_split_backend.h b/server/src/common/layer_split_backend.h index 9869a28b6..4f87ac1a2 100644 --- a/server/src/common/layer_split_backend.h +++ b/server/src/common/layer_split_backend.h @@ -103,6 +103,8 @@ class LayerSplitBackend : public ModelBackend { bool unpark(ParkTarget target) override; bool is_target_parked() const override { return false; } + bool supports_multimodal() const override; + GenerateResult generate_impl(const GenerateRequest & req, const DaemonIO & io) override; From abbe46a76cade626cc8f428b298c7a768019efc1 Mon Sep 17 00:00:00 2001 From: David Roth Date: Thu, 30 Jul 2026 06:55:12 -0500 Subject: [PATCH 06/10] fix(sync): gate Qwen35 supports_multimodal on DFLASH_HAVE_MMPROJ vision_ only exists when mmproj is enabled; ggml-only builds must not reference it from the inline override. --- server/src/qwen35/qwen35_backend.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/server/src/qwen35/qwen35_backend.h b/server/src/qwen35/qwen35_backend.h index bb6a0a487..38c7f2d2a 100644 --- a/server/src/qwen35/qwen35_backend.h +++ b/server/src/qwen35/qwen35_backend.h @@ -131,6 +131,11 @@ class Qwen35Backend : public ModelBackend { bool supports_dflash_spec_decode() const override { return true; } DFlashTarget * dflash_target() override; bool supports_remote_draft() const override { return true; } +#ifdef DFLASH_HAVE_MMPROJ + bool supports_multimodal() const override { return vision_ != nullptr; } +#else + bool supports_multimodal() const override { return false; } +#endif void shutdown() override; From 27b9a05944dfcd5fc318a9fa7a7119aaa2060161 Mon Sep 17 00:00:00 2001 From: David Roth Date: Fri, 31 Jul 2026 23:07:46 -0500 Subject: [PATCH 07/10] fix(vision): declare ModelBackend::supports_multimodal Layer-split and Qwen35 overrides need a base virtual; without it MMPROJ builds fail with 'marked override, but does not override'. --- server/src/common/model_backend.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/server/src/common/model_backend.h b/server/src/common/model_backend.h index 4380c9f0e..d9ea69fac 100644 --- a/server/src/common/model_backend.h +++ b/server/src/common/model_backend.h @@ -487,6 +487,9 @@ struct ModelBackend { // the server before startup. virtual bool supports_remote_draft() const { return false; } + // Native mmproj vision. LayerSplitBackend overrides to proxy the adapter. + virtual bool supports_multimodal() const { return false; } + // Layer-split capability introspection. Non layer-split backends keep the // default false; LayerSplitBackend proxies model-adapter support. virtual bool supports_kvflash() const { return false; } From 82d9a7d9a3f7949c4d835eae769b628b0cada3a6 Mon Sep 17 00:00:00 2001 From: David Roth Date: Fri, 31 Jul 2026 23:59:00 -0500 Subject: [PATCH 08/10] docs(vision): add mmproj guide with end-to-end example screenshot --- server/docs/VISION.md | 47 +++++++++++++++++++ .../images/vision-mmproj-meme-example.png | 3 ++ 2 files changed, 50 insertions(+) create mode 100644 server/docs/VISION.md create mode 100644 server/docs/images/vision-mmproj-meme-example.png diff --git a/server/docs/VISION.md b/server/docs/VISION.md new file mode 100644 index 000000000..9a7dc7263 --- /dev/null +++ b/server/docs/VISION.md @@ -0,0 +1,47 @@ +# Native mmproj vision + +Optional build (`-DDFLASH27B_MMPROJ=ON`) wires llama.cpp **mtmd** so +`dflash_server` can load a GGUF multimodal projector alongside the text model +and accept OpenAI-style `image_url` content in chat completions. + +## Runtime + +```bash +# Build +cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \ + -DDFLASH27B_MMPROJ=ON -DDFLASH27B_SERVER=ON +cmake --build build --target dflash_server -j"$(nproc)" + +# Serve (CLI or entrypoint env) +dflash_server ... --mmproj /path/to/mmproj-F16.gguf +# Container: DFLASH_MMPROJ=/path/to/mmproj-F16.gguf +# Optional: --no-mmproj-offload / DFLASH_MMPROJ_NO_OFFLOAD=1 +``` + +`/props` reports `capabilities.vision_supported: true` when the projector is +loaded. Multimodal turns run AR decode; text-only turns keep DFlash speculative +decode when configured. + +Supported on both monolithic Qwen35 and layer-split backends +(`supports_multimodal()` is delegated through `LayerSplitBackend`). + +## Example + +Chat completion with an attached meme image — the model reads the visual +layout and answers in natural language: + +![Native mmproj vision: meme interpretation](images/vision-mmproj-meme-example.png) + +Request shape (abbreviated): + +```json +{ + "messages": [{ + "role": "user", + "content": [ + {"type": "text", "text": "What do you think this image means?"}, + {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}} + ] + }] +} +``` diff --git a/server/docs/images/vision-mmproj-meme-example.png b/server/docs/images/vision-mmproj-meme-example.png new file mode 100644 index 000000000..ddde00341 --- /dev/null +++ b/server/docs/images/vision-mmproj-meme-example.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:621fc4cf760fa6035a43df7a92ca85a706a5e78376b535ff51d8eb47f28f0c60 +size 311492 From 317a1d7f487187d9f7ba06309cfb959e327d52df Mon Sep 17 00:00:00 2001 From: David Roth Date: Fri, 31 Jul 2026 23:59:19 -0500 Subject: [PATCH 09/10] docs(vision): store example screenshot outside LFS for PR/docs embeds --- .gitattributes | 1 + .../images/vision-mmproj-meme-example.png | Bin 131 -> 311492 bytes 2 files changed, 1 insertion(+) diff --git a/.gitattributes b/.gitattributes index e746fd25e..caa5d11aa 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2,6 +2,7 @@ *.png filter=lfs diff=lfs merge=lfs -text assets/banner.png -filter -diff -merge -text assets/docker.png -filter -diff -merge -text +server/docs/images/vision-mmproj-meme-example.png -filter -diff -merge -text *.jpg filter=lfs diff=lfs merge=lfs -text *.jpeg filter=lfs diff=lfs merge=lfs -text *.mp4 filter=lfs diff=lfs merge=lfs -text diff --git a/server/docs/images/vision-mmproj-meme-example.png b/server/docs/images/vision-mmproj-meme-example.png index ddde0034110976c7ae30cddbb207ff3a55c0a440..4f9451ef5a79366b152a5b6dc94b8981dad97933 100644 GIT binary patch literal 311492 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 EqO;fJPP+S5T!A<&?XaBEP1O2_d*)`j)_(ep} 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 Ni`lC!YWS From 122393626cf7bc488e6a27d2ea7069ff15316312 Mon Sep 17 00:00:00 2001 From: David Roth Date: Sat, 1 Aug 2026 08:24:16 -0500 Subject: [PATCH 10/10] docs(vision): add Quick start for testing mmproj builds --- server/docs/VISION.md | 77 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 69 insertions(+), 8 deletions(-) diff --git a/server/docs/VISION.md b/server/docs/VISION.md index 9a7dc7263..c34ac8004 100644 --- a/server/docs/VISION.md +++ b/server/docs/VISION.md @@ -4,23 +4,84 @@ Optional build (`-DDFLASH27B_MMPROJ=ON`) wires llama.cpp **mtmd** so `dflash_server` can load a GGUF multimodal projector alongside the text model and accept OpenAI-style `image_url` content in chat completions. -## Runtime +## Quick start + +**Need:** CUDA GPU, a Qwen3.5/3.6 GGUF + matching `mmproj-F16.gguf`, and a +**full** [`lucebox-ggml`](https://github.com/Luce-Org/lucebox-ggml) tree. +Hub only vendors the ggml subset — `tools/mtmd` is not in-tree — so a stock +configure with `-DDFLASH27B_MMPROJ=ON` will fail until mtmd sources are present. ```bash -# Build +# 1) Checkout this PR +git fetch origin pull/571/head:pr-571 && git checkout pr-571 + +# 2) Supply full llama.cpp (mtmd) for the build +cd server/deps +mv llama.cpp llama.cpp.vendored-ggml-only +git clone --depth 1 -b luce-dflash https://github.com/Luce-Org/lucebox-ggml.git llama.cpp +# Keep hub-local ggml patches (e.g. rocmfp4) on top of the full tree +cp -a llama.cpp.vendored-ggml-only/ggml/. llama.cpp/ggml/ + +# 3) Build with vision +cd .. cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_CUDA_ARCHITECTURES= \ -DDFLASH27B_MMPROJ=ON -DDFLASH27B_SERVER=ON cmake --build build --target dflash_server -j"$(nproc)" -# Serve (CLI or entrypoint env) -dflash_server ... --mmproj /path/to/mmproj-F16.gguf -# Container: DFLASH_MMPROJ=/path/to/mmproj-F16.gguf +# 4) Run (same flags you already use for Qwen35, plus mmproj) +./build/dflash_server \ + --model /path/to/Qwen….gguf \ + --mmproj /path/to/mmproj-F16.gguf \ + # …draft / layer-split / port as usual… + +# Container equivalent: +# DFLASH_MMPROJ=/path/to/mmproj-F16.gguf # Optional: --no-mmproj-offload / DFLASH_MMPROJ_NO_OFFLOAD=1 ``` -`/props` reports `capabilities.vision_supported: true` when the projector is -loaded. Multimodal turns run AR decode; text-only turns keep DFlash speculative -decode when configured. +After the build you can restore the slim vendor so the tree stays pullable: + +```bash +cd server/deps +rm -rf llama.cpp +mv llama.cpp.vendored-ggml-only llama.cpp +``` + +### Smoke + +```bash +# Capability flag +curl -s localhost:8080/props | jq '.capabilities.vision_supported' +# expect: true + +# Multimodal chat (data URI only today) +IMG_B64=$(base64 -w0 /path/to/test.jpg) # macOS: base64 -i test.jpg +curl -s localhost:8080/v1/chat/completions \ + -H 'Content-Type: application/json' \ + -d "{ + \"model\": \"qwen\", + \"messages\": [{ + \"role\": \"user\", + \"content\": [ + {\"type\": \"text\", \"text\": \"What do you see?\"}, + {\"type\": \"image_url\", \"image_url\": { + \"url\": \"data:image/jpeg;base64,${IMG_B64}\" + }} + ] + }], + \"max_tokens\": 128 +}" +``` + +Also check a plain text turn still works (and still uses DFlash when a draft is +configured). Without `--mmproj`, image requests should 400 cleanly. + +## Runtime + +Multimodal turns run AR decode; text-only turns keep DFlash speculative decode +when configured. `/props` reports `capabilities.vision_supported: true` when +the projector is loaded. Supported on both monolithic Qwen35 and layer-split backends (`supports_multimodal()` is delegated through `LayerSplitBackend`).