[NPUW] Model builder: LoRA robustness fixes + build_llm test coverage

LoRA stays explicitly threaded as a const LoRAInjector* through make_linear
and the Attention / SwiGLU / GELU functors (no global state).

- LoRAInjector::max_rank / precision get safe defaults (0 / f32) and
  should_adapt() returns false for max_rank == 0, so a default-constructed
  injector is an inert no-op.
- build_llm holds the injector on the stack and recreates only the default
  dense FFN as a LoRA-aware SwiGLU; custom and MoE FFN graphs are untouched.
- Add unit coverage for the build_llm LoRA path (attention + FFN adapted)
  and the no-LoRA negative case, alongside the build_lora_adapter checks.

Author: dylanneve1

src/plugins/intel_npu/tests/functional/behavior/npuw/test_engine/models/model_builder.cpp

@@ -83,8 +83,8 @@ ov::Output<ov::Node> make_linear(const ov::Output<ov::Node>& input,
         result = add->output(0);
     }
 
-    // LoRA injection: input -> MatMul(A^T) -> Multiply(alpha) -> MatMul(B^T) -> Add(base_output)
-    // Parameter names match NPUW lora_state_* pattern.
+    // LoRA injection: input -> MatMul(A^T) -> Multiply(alpha) -> MatMul(B^T) -> Add(base).
+    // Names match the NPUW lora_state_* convention.
     if (lora && lora->should_adapt(name)) {
         const size_t R = lora->max_rank;
         const auto prec = lora->precision;
@@ -804,20 +804,22 @@ std::shared_ptr<ov::Model> ModelBuilder::build_llm(const LLMConfig& config_in) {
     const auto hs = config.hidden_size;
     const auto kv_heads = config.get_kv_heads();
 
-    // Set up LoRA injector if requested
-    std::unique_ptr<LoRAInjector> lora_ptr;
-    if (config.lora_rank > 0) {
-        lora_ptr = std::make_unique<LoRAInjector>();
-        lora_ptr->max_rank = config.lora_rank;
-        lora_ptr->targets = config.lora_targets;
-        lora_ptr->precision = prec;
-        lora_ptr->stateful = config.lora_stateful;
-        lora_ptr->sinks = &m_sinks;
-        // Recreate only the default dense FFN with LoRA injection; preserve custom and MoE FFN graphs.
-        if (!has_custom_ffn && config.num_experts == 0)
-            config.ffn = SwiGLU(config.hidden_size, config.intermediate_size, prec, config.weight, lora_ptr.get());
+    LoRAInjector lora_injector;
+    const bool lora_enabled = config.lora_rank > 0;
+    if (lora_enabled) {
+        lora_injector.max_rank = config.lora_rank;
+        lora_injector.targets = config.lora_targets;
+        lora_injector.precision = prec;
+        lora_injector.stateful = config.lora_stateful;
+        lora_injector.sinks = &m_sinks;
+        // FFN is a functor (FFNFn); LoRA reaches it only through a struct that
+        // forwards the injector. Recreate the default dense FFN as a LoRA-aware
+        // SwiGLU; custom and MoE FFN graphs are left untouched.
+        if (!has_custom_ffn && config.num_experts == 0) {
+            config.ffn = SwiGLU(config.hidden_size, config.intermediate_size, prec, config.weight, &lora_injector);
+        }
     }
-    const LoRAInjector* lora = lora_ptr.get();
+    const LoRAInjector* lora = lora_enabled ? &lora_injector : nullptr;
 
     Attention attn{};
     attn.hidden_size = hs;

src/plugins/intel_npu/tests/functional/behavior/npuw/test_engine/models/model_builder_attention.hpp

@@ -85,7 +85,6 @@ struct Attention {
 
     ov::Output<ov::Node> sdpa_mask;
     ov::Output<ov::Node> shared_broadcast_shape;
-
     const LoRAInjector* lora = nullptr;
 
     std::string o_proj_name = "self_attn.o_proj";

src/plugins/intel_npu/tests/functional/behavior/npuw/test_engine/models/model_builder_types.hpp

@@ -49,13 +49,16 @@ using KVCacheFn =
 ///   output = base_linear_out + (input @ A^T * alpha) @ B^T
 /// Names follow the NPUW lora_state_* convention.
 struct LoRAInjector {
-    size_t max_rank;
+    size_t max_rank = 0;
     std::vector<std::string> targets;
-    ov::element::Type precision;
+    ov::element::Type precision = ov::element::f32;
     bool stateful = false;
     ov::SinkVector* sinks = nullptr;
 
     bool should_adapt(const std::string& name) const {
+        if (max_rank == 0) {
+            return false;
+        }
         if (targets.empty()) {
             // Default target set
             static const std::vector<std::string> defaults =

src/plugins/intel_npu/tests/unit/npuw/llm_test_helpers.hpp

@@ -155,6 +155,18 @@ inline std::shared_ptr<ov::Model> build_moe_llm_test_model() {
     return mb.build_llm(cfg);
 }
 
+inline std::shared_ptr<ov::Model> build_lora_adapter_test_model() {
+    ModelBuilder mb;
+    return mb.build_lora_adapter(make_test_model_config<LoRAConfig>());
+}
+
+inline std::shared_ptr<ov::Model> build_lora_llm_test_model() {
+    auto cfg = make_test_model_config();
+    cfg.lora_rank = 8;
+    ModelBuilder mb;
+    return mb.build_llm(cfg);
+}
+
 
 class NullPlugin : public ov::IPlugin {
 public:

src/plugins/intel_npu/tests/unit/npuw/model_builder_lora_test.cpp

@@ -7,7 +7,7 @@
 #include <memory>
 #include <string>
 
-#include "model_builder.hpp"
+#include "llm_test_helpers.hpp"
 
 namespace {
 
@@ -21,15 +21,7 @@ bool has_param(const std::shared_ptr<ov::Model>& m, const std::string& needle) {
 }
 
 TEST(ModelBuilderLoraTest, StatelessAdapterExposesLoraParameters) {
-    ov::test::npuw::ModelBuilder builder;
-    ov::test::npuw::LoRAConfig config;
-    config.num_layers = 1;
-    config.hidden_size = 8;
-    config.vocab_size = 32;
-    config.precision = ov::element::f16;
-    config.lora_targets = {"q_proj", "v_proj"};
-
-    auto model = builder.build_lora_adapter(config);
+    auto model = ov::test::npuw::build_lora_adapter_test_model();
     ASSERT_TRUE(model);
     EXPECT_TRUE(has_param(model, "lora_state_"));
     EXPECT_TRUE(has_param(model, "q_proj.MatMul.A"));
@@ -40,17 +32,25 @@ TEST(ModelBuilderLoraTest, StatelessAdapterExposesLoraParameters) {
 
 TEST(ModelBuilderLoraTest, StatefulAdapterExposesLoraStates) {
     ov::test::npuw::ModelBuilder builder;
-    ov::test::npuw::LoRAConfig config;
-    config.num_layers = 1;
-    config.hidden_size = 8;
-    config.vocab_size = 32;
-    config.precision = ov::element::f16;
-    config.lora_targets = {"q_proj"};
+    auto config = ov::test::npuw::make_test_model_config<ov::test::npuw::LoRAConfig>();
     config.lora_stateful = true;
 
     auto model = builder.build_lora_adapter(config);
     ASSERT_TRUE(model);
     EXPECT_FALSE(model->get_sinks().empty());
 }
 
+TEST(ModelBuilderLoraTest, BuildLlmInjectsLoraIntoAttentionAndFfn) {
+    auto model = ov::test::npuw::build_lora_llm_test_model();
+    ASSERT_TRUE(model);
+    EXPECT_TRUE(has_param(model, "q_proj.MatMul.A"));
+    EXPECT_TRUE(has_param(model, "down_proj.MatMul.A"));
+}
+
+TEST(ModelBuilderLoraTest, BuildLlmWithoutLoraHasNoLoraParameters) {
+    auto model = ov::test::npuw::build_llm_test_model();
+    ASSERT_TRUE(model);
+    EXPECT_FALSE(has_param(model, "lora_state_"));
+}
+
 }  // namespace