chat : fix reasoning leak with force-opened bare <think> templates (#24674)

* chat : fix reasoning leak with force-opened bare <think> templates

The reasoning start tag inferred from prior turns can carry trailing
whitespace (e.g. <think>\n) while a force-open template prefills a bare
<think>. Trim the tag used for the prefix split so the bare prefill is
matched instead of being swallowed into content.

* chat : fix Nemotron Nano v2 regression

---------

Co-authored-by: Alde Rojas <hello@alde.dev>

common/chat-auto-parser-generator.cpp

@@ -147,7 +147,8 @@ common_peg_arena autoparser::build_parser(const generation_params & inputs, cons
         } else {
             parser = content.build_parser(ctx);
         }
-        return pure_content ? p.prefix(generation_prompt, reasoning.start) + parser : p.prefix(generation_prompt, reasoning.start) << parser;
+        const std::string reasoning_start = trim_whitespace(reasoning.start);
+        return pure_content ? p.prefix(generation_prompt, reasoning_start) + parser : p.prefix(generation_prompt, reasoning_start) << parser;
     });
 }
 

common/chat-diff-analyzer.cpp

@@ -124,16 +124,16 @@ static std::vector<std::function<void(const common_chat_template & tmpl, autopar
               analysis.tools.format.section_end    = "";
               analysis.tools.format.per_call_start = "<TOOLCALL>";
               analysis.tools.format.per_call_end   = "</TOOLCALL>";
+              analysis.tools.format.tools_array_wrapped = true;
               analysis.content.mode                = content_mode::PLAIN;
               analysis.content.start               = "";
               analysis.content.end                 = "";
               analysis.reasoning.mode              = reasoning_mode::TAG_BASED;
-              analysis.reasoning.start             = "<think>\n\n";
+              analysis.reasoning.start             = "<think>\n";
               analysis.reasoning.end               = "</think>";
               analysis.assistant_start             = "<SPECIAL_11>Assistant";
               analysis.user_start                  = "<SPECIAL_11>User";
               analysis.preserved_tokens.clear();
-              analysis.preserved_tokens.push_back("<SPECIAL_12>");
               analysis.preserved_tokens.push_back("<SPECIAL_11>");
               analysis.preserved_tokens.push_back("</think>");
               analysis.preserved_tokens.push_back("<TOOLCALL>");

docs/backend/SYCL.md

@@ -795,6 +795,7 @@ use 1 SYCL GPUs: [0] with Max compute units:512
 | GGML_SYCL_USE_LEVEL_ZERO_API | 1 (default) or 0 | Use Level Zero API for device memory allocation instead of SYCL. Reduces system RAM usage on Intel dGPUs by avoiding DMA-buf/TTM host memory staging. Requires GGML_SYCL_SUPPORT_LEVEL_ZERO_API=ON at build time. SYCL backend always runs on Level Zero running time even if it's set as OFF (The SYCL api will be usage for memory allocation).|
 | GGML_SYCL_ENABLE_DNN | 0 or 1 (default)| Enable running computations through oneDNN and always use oneMKL. |
 | GGML_SYCL_ENABLE_VMM | 0 or 1 (default) | Enable the virtual-memory device pool. |
+| GGML_SYCL_ENABLE_FUSION | 0 or 1 (default) | Enable fused-kernel dispatch in graph compute (currently top-k MoE gating). |
 | ZES_ENABLE_SYSMAN | 0 (default) or 1 | Support to get free memory of GPU by sycl::aspect::ext_intel_free_memory.<br>Recommended to use when --split-mode = layer |
 | UR_L0_ENABLE_RELAXED_ALLOCATION_LIMITS | 0 (default) or 1 | Allow SYCL/Unified Runtime Level Zero device allocations larger than 4 GiB. llama.cpp's direct Level Zero allocation path requests the relaxed maximum-size limit itself when GGML_SYCL_ENABLE_LEVEL_ZERO=1. |
 | GGML_SYCL_USM_SYSTEM | 0 (default) or 1 | Enable experimental support for [USM system allocations](https://github.khronos.org/SYCL_Reference/iface/usm_basic_concept.html#system-allocations) for large GPU buffers. This requires enough host memory for model weights and caches, an Intel Xe2+ GPU such as BMG or newer and supported on Linux only, with CONFIG_DRM_XE_GPUSVM enabled. |

ggml/src/ggml-sycl/backend.hpp

@@ -42,6 +42,7 @@
 #include "set_rows.hpp"
 #include "ssm_conv.hpp"
 #include "softmax.hpp"
+#include "topk-moe.hpp"
 #include "tsembd.hpp"
 #include "upscale.hpp"
 #include "wkv.hpp"

ggml/src/ggml-sycl/common.hpp

@@ -60,6 +60,7 @@ void ggml_sycl_host_free(void* ptr);
 
 extern int g_ggml_sycl_debug;
 extern int g_ggml_sycl_enable_optimize;
+extern int g_ggml_sycl_enable_fusion;
 extern int g_ggml_sycl_prioritize_dmmv;
 extern int g_ggml_sycl_enable_flash_attention;
 extern int g_ggml_sycl_dev2dev_memcpy;

ggml/src/ggml-sycl/dmmv.cpp

@@ -377,6 +377,104 @@ static void dequantize_mul_mat_vec_q2_k(const void *__restrict__ vx,
     }
 }
 
+static void dequantize_mul_mat_vec_q2_k_reorder(const void *__restrict__ vx,
+                                                const float *__restrict__ yy,
+                                                float *__restrict__ dst,
+                                                const int ncols, int nrows,
+                                                const sycl::nd_item<3> &item_ct1) {
+
+    static_assert(16%K_QUANTS_PER_ITERATION == 0, "16 must be divisible by K_QUANTS_PER_ITERATION");
+
+    const int row = item_ct1.get_group(2) * item_ct1.get_local_range(1) +
+                    item_ct1.get_local_id(1);
+    if (row > nrows) return;
+
+    const int num_blocks_per_row = ncols / QK_K;
+    const int ib0 = row*num_blocks_per_row;
+
+    // SOA base pointers for the reordered layout:
+    //   [qs: nb * (QK_K/4)] [scales: nb * (QK_K/16)] [dm: nb * sizeof(half2)]
+    const int nb = nrows * num_blocks_per_row;
+    const uint8_t     * qs_base     = (const uint8_t *)vx;
+    const uint8_t     * scales_base = qs_base + (size_t)nb * (QK_K / 4);
+    const sycl::half2 * dm_base     = (const sycl::half2 *)(scales_base + (size_t)nb * (QK_K / 16));
+
+    float tmp = 0; // partial sum for thread in warp
+
+#if QK_K == 256
+    const int tid =
+        item_ct1.get_local_id(2) / K_QUANTS_PER_ITERATION; // 0...7 or 0...15
+    const int ix =
+        item_ct1.get_local_id(2) % K_QUANTS_PER_ITERATION; // 0 or 0,1
+
+    const int step = 16/K_QUANTS_PER_ITERATION;
+
+    const int in = tid % step;                           // 0...15 or 0...7
+
+    const int l0 = K_QUANTS_PER_ITERATION*in;            // 0...15 or 0...14 in steps of 2
+
+    uint32_t aux[4];
+    const uint8_t * d = (const uint8_t *)aux;
+    const uint8_t * m = (const uint8_t *)(aux + 2);
+
+    for (int i = ix; i < num_blocks_per_row; i += K_QUANTS_PER_ITERATION) {
+        const int bi = ib0 + i;
+
+        const sycl::half2 dm_val = dm_base[bi];
+        const float dall = dm_val[0];
+        const float dmin = dm_val[1];
+
+        for (int im = 0; im < 2; ++im) {
+            const int q_offset = 32*im + l0;
+            const int s_offset = 8*im;
+            const int y_offset = 128*im + l0;
+
+            const float   * y = yy + i * QK_K + y_offset;
+            const uint8_t * q = qs_base + bi * (QK_K / 4) + q_offset;
+
+            const uint32_t * a = (const uint32_t *)(scales_base + bi * (QK_K / 16) + s_offset);
+            aux[0] = a[0] & 0x0f0f0f0f;
+            aux[1] = a[1] & 0x0f0f0f0f;
+            aux[2] = (a[0] >> 4) & 0x0f0f0f0f;
+            aux[3] = (a[1] >> 4) & 0x0f0f0f0f;
+
+            float sum1 = 0, sum2 = 0;
+            for (int l = 0; l < K_QUANTS_PER_ITERATION; ++l) {
+                sum1 += y[l+ 0] * d[0] * ((q[l+ 0] >> 0) & 3)
+                      + y[l+32] * d[2] * ((q[l+ 0] >> 2) & 3)
+                      + y[l+64] * d[4] * ((q[l+ 0] >> 4) & 3)
+                      + y[l+96] * d[6] * ((q[l+ 0] >> 6) & 3)
+                      + y[l+16] * d[1] * ((q[l+16] >> 0) & 3)
+                      + y[l+48] * d[3] * ((q[l+16] >> 2) & 3)
+                      + y[l+80] * d[5] * ((q[l+16] >> 4) & 3)
+                      +y[l+112] * d[7] * ((q[l+16] >> 6) & 3);
+                sum2 += y[l+ 0] * m[0] + y[l+32] * m[2] + y[l+64] * m[4] + y[ l+96] * m[6]
+                      + y[l+16] * m[1] + y[l+48] * m[3] + y[l+80] * m[5] + y[l+112] * m[7];
+
+            }
+            tmp += dall * sum1 - dmin * sum2;
+        }
+    }
+#else
+    GGML_UNUSED(vx);
+    GGML_UNUSED(yy);
+    GGML_UNUSED(ncols);
+    GGML_UNUSED(item_ct1);
+    GGML_ABORT("Q2_K reorder DMMV not supported for QK_K != 256");
+#endif
+
+    // sum up partial sums and write back result
+#pragma unroll
+    for (int mask = WARP_SIZE / 2; mask > 0; mask >>= 1) {
+        tmp +=
+            dpct::permute_sub_group_by_xor(item_ct1.get_sub_group(), tmp, mask);
+    }
+
+    if (item_ct1.get_local_id(2) == 0) {
+        dst[row] = tmp;
+    }
+}
+
 static void dequantize_mul_mat_vec_q3_k(const void *__restrict__ vx,
                                         const float *__restrict__ yy,
                                         float *__restrict__ dst,
@@ -1664,6 +1762,22 @@ static void dequantize_mul_mat_vec_q2_K_sycl(const void *vx, const float *y,
         });
 }
 
+static void dequantize_mul_mat_vec_q2_K_sycl_reorder(const void *vx, const float *y,
+                                                     float *dst, const int ncols,
+                                                     const int nrows,
+                                                     dpct::queue_ptr stream) {
+    GGML_ASSERT(ncols % QK_K == 0);
+    const int ny = 2 / K_QUANTS_PER_ITERATION;
+    const int block_num_y = (nrows + ny - 1) / ny;
+    const sycl::range<3> block_nums(1, 1, block_num_y);
+    const sycl::range<3> block_dims(1, ny, WARP_SIZE);
+    stream->parallel_for(
+        sycl::nd_range<3>(block_nums * block_dims, block_dims),
+        [=](sycl::nd_item<3> item_ct1) [[sycl::reqd_sub_group_size(WARP_SIZE)]] {
+            dequantize_mul_mat_vec_q2_k_reorder(vx, y, dst, ncols, nrows, item_ct1);
+        });
+}
+
 static void dequantize_mul_mat_vec_q3_K_sycl(const void *vx, const float *y,
                                              float *dst, const int ncols,
                                              const int nrows,
@@ -1859,7 +1973,12 @@ void ggml_sycl_op_dequantize_mul_mat_vec(
             }
             break;
         case GGML_TYPE_Q2_K:
-            dequantize_mul_mat_vec_q2_K_sycl(src0_dd_i, src1_ddf_i, dst_dd_i, ne00, row_diff, stream);
+            if ((ggml_tensor_extra_gpu *) dst->src[0]->extra &&
+                ((ggml_tensor_extra_gpu *) dst->src[0]->extra)->optimized_feature.reorder) {
+                dequantize_mul_mat_vec_q2_K_sycl_reorder(src0_dd_i, src1_ddf_i, dst_dd_i, ne00, row_diff, stream);
+            } else {
+                dequantize_mul_mat_vec_q2_K_sycl(src0_dd_i, src1_ddf_i, dst_dd_i, ne00, row_diff, stream);
+            }
             break;
         case GGML_TYPE_Q3_K:
             if ((ggml_tensor_extra_gpu *) dst->src[0]->extra &&

ggml/src/ggml-sycl/ggml-sycl.cpp

@@ -85,6 +85,7 @@ int g_ggml_sycl_enable_optimize = 1;
 int g_ggml_sycl_enable_graph = 0;
 int g_ggml_sycl_enable_dnn = 1;
 int g_ggml_sycl_enable_vmm = 1;
+int g_ggml_sycl_enable_fusion = 1;
 int g_ggml_sycl_prioritize_dmmv = 0;
 int g_ggml_sycl_use_async_mem_op = 0;
 int g_ggml_sycl_use_async_mem_op_requested = 1;
@@ -285,6 +286,7 @@ static void ggml_check_sycl() try {
         g_ggml_sycl_enable_graph = ggml_sycl_get_env("GGML_SYCL_ENABLE_GRAPH", 0);
         g_ggml_sycl_enable_dnn = ggml_sycl_get_env("GGML_SYCL_ENABLE_DNN", 1);
         g_ggml_sycl_enable_vmm = ggml_sycl_get_env("GGML_SYCL_ENABLE_VMM", 1);
+        g_ggml_sycl_enable_fusion = ggml_sycl_get_env("GGML_SYCL_ENABLE_FUSION", 1);
         g_ggml_sycl_prioritize_dmmv = ggml_sycl_get_env("GGML_SYCL_PRIORITIZE_DMMV", 0);
 
         g_ggml_sycl_dev2dev_memcpy = ggml_sycl_get_env("GGML_SYCL_DEV2DEV_MEMCPY", DEV2DEV_MEMCPY_SYCL);
@@ -353,7 +355,6 @@ static void ggml_check_sycl() try {
 #else
         GGML_LOG_INFO("  GGML_SYCL_ENABLE_DNN: DNN disabled by compile flag\n");
 #endif
-
 #ifdef SYCL_FLASH_ATTN
         GGML_LOG_INFO("  GGML_SYCL_ENABLE_FLASH_ATTN: %d\n", g_ggml_sycl_enable_flash_attention);
 #else
@@ -375,6 +376,8 @@ static void ggml_check_sycl() try {
         GGML_LOG_INFO("  GGML_SYCL_ENABLE_VMM: virtual memory extension is not available\n");
 #endif
 
+        GGML_LOG_INFO("  GGML_SYCL_ENABLE_FUSION: %d\n", g_ggml_sycl_enable_fusion);
+
         GGML_LOG_INFO("  GGML_SYCL_PRIORITIZE_DMMV: %d\n", g_ggml_sycl_prioritize_dmmv);
 
         g_ggml_sycl_use_async_mem_op_requested = ggml_sycl_get_env("GGML_SYCL_USE_ASYNC_MEM_OP", 1);
@@ -547,6 +550,7 @@ ggml_backend_sycl_buffer_init_tensor(ggml_backend_buffer_t buffer,
         switch (tensor->type) {
             case GGML_TYPE_Q4_0:
             case GGML_TYPE_Q8_0:
+            case GGML_TYPE_Q2_K:
             case GGML_TYPE_Q3_K:
             case GGML_TYPE_Q4_K:
             case GGML_TYPE_Q5_K:
@@ -3675,6 +3679,7 @@ inline bool ggml_sycl_supports_reorder_mul_mat_sycl(enum ggml_type type) {
         case GGML_TYPE_Q4_0:
         case GGML_TYPE_Q8_0:
             return true;
+        case GGML_TYPE_Q2_K:
         case GGML_TYPE_Q3_K:
         case GGML_TYPE_Q4_K:
         case GGML_TYPE_Q5_K:
@@ -3690,6 +3695,7 @@ inline bool ggml_sycl_supports_reorder_dmmv(enum ggml_type type) {
         case GGML_TYPE_Q1_0:
         case GGML_TYPE_Q4_0:
         case GGML_TYPE_Q8_0:
+        case GGML_TYPE_Q2_K:
         case GGML_TYPE_Q3_K:
         case GGML_TYPE_Q4_K:
         case GGML_TYPE_Q5_K:
@@ -4069,6 +4075,49 @@ static bool reorder_qw_q6_k_moe(uint8_t * data_device, size_t expert_bytes, int6
     return true;
 }
 
+static bool reorder_qw_q2_k(uint8_t * data_device, size_t size, size_t offset, dpct::queue_ptr stream) {
+    GGML_ASSERT(size % sizeof(block_q2_K) == 0);
+    GGML_ASSERT(offset % sizeof(block_q2_K) == 0);
+
+    const int nblocks = size / sizeof(block_q2_K);
+
+    sycl_reorder_temp_buffer tmp(stream, size);
+    if (!tmp) {
+        GGML_LOG_WARN("%s: failed to allocate %zu bytes for reorder temp buffer, skipping reorder\n", __func__, size);
+        return false;
+    }
+    uint8_t * tmp_buf = static_cast<uint8_t *>(tmp.ptr);
+
+    sycl::event copy_event;
+    SYCL_CHECK(CHECK_TRY_ERROR(copy_event = stream->memcpy(tmp_buf, data_device, size)));
+    if (!g_ggml_sycl_use_async_mem_op) {
+        copy_event.wait();
+    }
+
+    auto *        qs_ptr     = data_device;
+    auto *        scales_ptr = qs_ptr + (QK_K / 4) * nblocks;
+    sycl::half2 * dm_ptr     = (sycl::half2 *) (scales_ptr + (QK_K / 16) * nblocks);
+
+    auto reorder_event = stream->parallel_for(nblocks, [=](auto i) {
+        const block_q2_K * x  = (const block_q2_K *) tmp_buf;
+        const int          ib = i;
+
+        for (int j = 0; j < QK_K / 4; ++j) {
+            qs_ptr[ib * (QK_K / 4) + j] = x[ib].qs[j];
+        }
+
+        for (int j = 0; j < QK_K / 16; ++j) {
+            scales_ptr[ib * (QK_K / 16) + j] = x[ib].scales[j];
+        }
+
+        dm_ptr[ib] = x[ib].dm;
+    });
+    if (!g_ggml_sycl_use_async_mem_op) {
+        reorder_event.wait_and_throw();
+    }
+    return true;
+}
+
 static bool reorder_qw_q3_k(uint8_t * data_device, size_t size, size_t offset, dpct::queue_ptr stream) {
     GGML_ASSERT(size % sizeof(block_q3_K) == 0);
     GGML_ASSERT(offset % sizeof(block_q3_K) == 0);
@@ -4245,6 +4294,8 @@ static bool reorder_qw(const ggml_tensor * src0, dpct::queue_ptr stream) {
             return reorder_qw_q4_0(data_device, ncols, nrows, size, 0, stream);
         case GGML_TYPE_Q8_0:
             return reorder_qw_q8_0(data_device, ncols, nrows, size, 0, stream);
+        case GGML_TYPE_Q2_K:
+            return reorder_qw_q2_k(data_device, size, 0, stream);
         case GGML_TYPE_Q3_K:
             return reorder_qw_q3_k(data_device, size, 0, stream);
         case GGML_TYPE_Q4_K:
@@ -5322,6 +5373,12 @@ static void ggml_backend_sycl_graph_compute_impl(ggml_backend_sycl_context * syc
         if ((node->flags & GGML_TENSOR_FLAG_COMPUTE) == 0) {
             continue;
         }
+
+        const int nodes_to_skip = ggml_sycl_fuse(*sycl_ctx, cgraph, i);
+        if (nodes_to_skip != 0) {
+            i += nodes_to_skip;
+            continue;
+        }
 #ifndef NDEBUG
         assert(node->buffer->buft == ggml_backend_sycl_buffer_type(sycl_ctx->device));
         for (int j = 0; j < GGML_MAX_SRC; j++) {

ggml/src/ggml-sycl/topk-moe.cpp

@@ -0,0 +1,620 @@
+#include <cfloat>
+#include <initializer_list>
+#include <vector>
+
+#include "ggml.h"
+#include "ggml-impl.h"
+#include "ggml-backend-impl.h"
+#include "topk-moe.hpp"
+
+// SYCL port of ggml-cuda/topk-moe.cu. The kernel is a translation of the CUDA no-bias, no-PDL
+// path of topk_moe_cuda; the fusion-detection helpers below are ported near-verbatim from
+// ggml-cuda.cu (pure graph / pointer inspection, backend-agnostic). Bias is not implemented here:
+// if a routing bias is detected, the fusion is declined and the eager path runs unchanged.
+
+struct ggml_sycl_topk_moe_args {
+    bool sigmoid{};
+    bool softmax{};
+    bool delayed_softmax{};
+    bool prob_bias{};
+    bool norm{};
+    bool scale{};
+};
+
+struct topk_moe_config {
+    bool use_sigmoid;
+    bool with_norm;
+    bool delayed_softmax;
+};
+
+// warp-local softmax used for both the pre-top-k logits and the post-top-k delayed path
+template <int experts_per_thread, bool use_limit>
+static inline void softmax_warp_inplace(float (&vals)[experts_per_thread], const int limit, const int lane) {
+    float max_val = -INFINITY;
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        const int  idx    = lane + i * WARP_SIZE;
+        const bool active = !use_limit || (idx < limit);
+        if (active) {
+            max_val = sycl::fmax(max_val, vals[i]);
+        }
+    }
+    max_val = warp_reduce_max<WARP_SIZE>(max_val);
+
+    float sum = 0.f;
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        const int  idx    = lane + i * WARP_SIZE;
+        const bool active = !use_limit || (idx < limit);
+        if (active) {
+            const float val = sycl::exp(vals[i] - max_val);
+            vals[i]         = val;
+            sum += val;
+        } else {
+            vals[i] = 0.f;
+        }
+    }
+    sum = warp_reduce_sum<WARP_SIZE>(sum);
+
+    const float inv_sum = 1.0f / sum;
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        const int idx = lane + i * WARP_SIZE;
+        if (!use_limit || idx < limit) {
+            vals[i] *= inv_sum;
+        }
+    }
+}
+
+template <int experts_per_thread, bool use_limit>
+static inline void sigmoid_warp_inplace(float (&vals)[experts_per_thread], const int limit, const int lane) {
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        const int  idx    = lane + i * WARP_SIZE;
+        const bool active = !use_limit || (idx < limit);
+        vals[i]           = active ? 1.f / (1.f + sycl::exp(-vals[i])) : -INFINITY;
+    }
+}
+
+/*
+    This kernel does the following:
+    1. optionally softmax/sigmoid over the logits per token [n_experts, n_tokens]
+    2. argmax reduce over the top-k (n_experts_used) logits
+    3. write weights + ids to global memory
+    4. optionally normalize the weights or apply softmax over the selected logits
+
+    It is intended as a fusion of the softmax->top-k->get_rows pipeline for MoE models.
+    One sub-group handles one row/token, mirroring topk_moe_cuda's one-warp-per-row layout.
+*/
+template <int n_experts>
+static void topk_moe_kernel(const float * __restrict__ logits,
+                            float * __restrict__       weights,
+                            int32_t * __restrict__     ids,
+                            const int                  n_rows,
+                            const int                  n_expert_used,
+                            const float                clamp_val,
+                            const float                scale_val,
+                            const topk_moe_config       config) {
+    auto      item_ct1 = sycl::ext::oneapi::this_work_item::get_nd_item<1>();
+    const int row       = item_ct1.get_group(0);
+    if (row >= n_rows) {
+        return;
+    }
+    const int lane = item_ct1.get_local_id(0);
+
+    logits  += (size_t) n_experts * row;
+    weights += (size_t) n_expert_used * row;
+    ids     += (size_t) n_experts * row;  // ids row stride is n_experts (matches the argsort tensor)
+
+    constexpr int experts_per_thread = (n_experts > WARP_SIZE) ? n_experts / WARP_SIZE : 1;
+
+    float wt[experts_per_thread];
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        wt[i] = -INFINITY;
+    }
+#pragma unroll
+    for (int i = 0; i < n_experts; i += WARP_SIZE) {
+        const int expert  = i + lane;
+        wt[i / WARP_SIZE] = (n_experts % WARP_SIZE == 0 || expert < n_experts) ? logits[expert] : -INFINITY;
+    }
+
+    if (!config.delayed_softmax) {
+        if (config.use_sigmoid) {
+            sigmoid_warp_inplace<experts_per_thread, false>(wt, n_experts, lane);
+        } else {
+            softmax_warp_inplace<experts_per_thread, false>(wt, n_experts, lane);
+        }
+    }
+
+    // Sanitize NaN to -FLT_MAX so the iterative argmax produces unique expert IDs. NaN comparisons
+    // always return false, which would cause the same expert to be selected repeatedly.
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        if (sycl::isnan(wt[i])) {
+            wt[i] = -FLT_MAX;
+        }
+    }
+
+    // each thread now holds either a portion of the softmax distribution or the raw logits. Do the
+    // argmax reduce over n_expert_used, each time marking the selected expert as -inf to exclude it
+    // from the next iteration.
+
+    float wt_sum = 0.f;
+    float output_weights[experts_per_thread];
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        output_weights[i] = 0.f;
+    }
+
+    const sycl::sub_group sg = item_ct1.get_sub_group();
+
+    for (int k = 0; k < n_expert_used; k++) {
+        float max_val    = wt[0];
+        int   max_expert = lane;
+#pragma unroll
+        for (int i = 1; i < experts_per_thread; i++) {
+            const int expert = lane + i * WARP_SIZE;
+            if ((n_experts % WARP_SIZE == 0 || expert < n_experts) && wt[i] > max_val) {
+                max_val    = wt[i];
+                max_expert = expert;
+            }
+        }
+#pragma unroll
+        for (int mask = WARP_SIZE / 2; mask > 0; mask >>= 1) {
+            const float val    = dpct::permute_sub_group_by_xor(sg, max_val, mask);
+            const int   expert = dpct::permute_sub_group_by_xor(sg, max_expert, mask);
+            if (val > max_val || (val == max_val && expert < max_expert)) {
+                max_val    = val;
+                max_expert = expert;
+            }
+        }
+
+        if ((max_expert & (WARP_SIZE - 1)) == lane) {
+            wt[max_expert / WARP_SIZE] = -INFINITY;
+        }
+        if ((k & (WARP_SIZE - 1)) == lane) {
+            output_weights[k / WARP_SIZE] = max_val;
+        }
+        if ((max_expert & (WARP_SIZE - 1)) == lane) {
+            ids[k] = max_expert;
+            if (config.with_norm) {
+                wt_sum += max_val;
+            }
+        }
+    }
+
+    if (config.with_norm) {
+        wt_sum          = warp_reduce_sum<WARP_SIZE>(wt_sum);
+        wt_sum          = sycl::fmax(wt_sum, clamp_val);
+        const float inv = 1.0f / wt_sum;
+#pragma unroll
+        for (int i = 0; i < experts_per_thread; i++) {
+            output_weights[i] *= inv;
+        }
+    }
+
+    if (config.delayed_softmax) {
+        softmax_warp_inplace<experts_per_thread, true>(output_weights, n_expert_used, lane);
+    }
+
+#pragma unroll
+    for (int i = 0; i < experts_per_thread; i++) {
+        const int idx = i * WARP_SIZE + lane;
+        if (idx < n_expert_used) {
+            weights[idx] = output_weights[i] * scale_val;
+        }
+    }
+}
+
+template <int n_experts>
+static void launch_topk_moe(queue_ptr stream, const float * logits, float * weights, int32_t * ids, int n_rows,
+                            int n_expert_used, float clamp_val, float scale_val, const topk_moe_config & config) {
+    const sycl::range<1> block_dims(WARP_SIZE);
+    const sycl::range<1> block_nums(n_rows);
+    stream->parallel_for(sycl::nd_range<1>(block_nums * block_dims, block_dims),
+                         [=](sycl::nd_item<1> item_ct1) [[sycl::reqd_sub_group_size(WARP_SIZE)]] {
+                             topk_moe_kernel<n_experts>(logits, weights, ids, n_rows, n_expert_used, clamp_val,
+                                                        scale_val, config);
+                             GGML_UNUSED(item_ct1);
+                         });
+}
+
+static void ggml_sycl_op_topk_moe(ggml_backend_sycl_context &     ctx,
+                                  const ggml_tensor *             logits,
+                                  ggml_tensor *                   weights,
+                                  ggml_tensor *                   ids,
+                                  const ggml_tensor *             clamp,
+                                  const ggml_tensor *             scale,
+                                  const ggml_sycl_topk_moe_args & args) {
+    GGML_ASSERT(logits->type  == GGML_TYPE_F32);
+    GGML_ASSERT(weights->type == GGML_TYPE_F32);
+    GGML_ASSERT(ids->type     == GGML_TYPE_I32);
+
+    const int n_experts     = logits->ne[0];
+    const int n_rows        = logits->ne[1];
+    const int n_expert_used = weights->ne[1];
+
+    GGML_ASSERT(ids->nb[1] / ggml_type_size(ids->type) == (size_t) n_experts);
+
+    const float * logits_d  = (const float *) logits->data;
+    float *       weights_d = (float *) weights->data;
+    int32_t *     ids_d     = (int32_t *) ids->data;
+
+    const bool  with_norm = clamp != nullptr;
+    const float clamp_val = clamp ? ggml_get_op_params_f32(clamp, 0) : -INFINITY;
+    const float scale_val = scale ? ggml_get_op_params_f32(scale, 0) : 1.0f;
+
+    topk_moe_config config;
+    config.use_sigmoid     = args.sigmoid;
+    config.with_norm       = with_norm;
+    config.delayed_softmax = args.delayed_softmax;
+
+    queue_ptr stream = ctx.stream();
+    ggml_sycl_set_device(ctx.device);
+
+    switch (n_experts) {
+        case 1:
+            launch_topk_moe<1>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                               config);
+            break;
+        case 2:
+            launch_topk_moe<2>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                               config);
+            break;
+        case 4:
+            launch_topk_moe<4>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                               config);
+            break;
+        case 8:
+            launch_topk_moe<8>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                               config);
+            break;
+        case 16:
+            launch_topk_moe<16>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                                config);
+            break;
+        case 32:
+            launch_topk_moe<32>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                                config);
+            break;
+        case 64:
+            launch_topk_moe<64>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                                config);
+            break;
+        case 128:
+            launch_topk_moe<128>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                                 config);
+            break;
+        case 256:
+            launch_topk_moe<256>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                                 config);
+            break;
+        case 512:
+            launch_topk_moe<512>(stream, logits_d, weights_d, ids_d, n_rows, n_expert_used, clamp_val, scale_val,
+                                 config);
+            break;
+        default:
+            GGML_ASSERT(false && "fatal error");
+            break;
+    }
+}
+
+static bool ggml_sycl_should_use_topk_moe(const ggml_tensor * gating_op, const ggml_tensor * weights,
+                                          const ggml_tensor * logits, const ggml_tensor * ids) {
+    const int n_expert = ids->nb[1] / ids->nb[0];
+    if ((n_expert & (n_expert - 1)) != 0 || n_expert > 512) {
+        return false;
+    }
+
+    if (!ggml_is_contiguous(weights) || !ggml_is_contiguous(logits)) {
+        return false;
+    }
+
+    if (gating_op->op == GGML_OP_SOFT_MAX) {
+        float scale    = 1.0f;
+        float max_bias = 0.0f;
+
+        memcpy(&scale, (const float *) gating_op->op_params + 0, sizeof(float));
+        memcpy(&max_bias, (const float *) gating_op->op_params + 1, sizeof(float));
+
+        if (!ggml_is_contiguous(gating_op->src[0])) {
+            return false;
+        }
+        if (scale != 1.0f || max_bias != 0.0f) {
+            return false;
+        }
+        // don't fuse when masks or sinks are present
+        if (gating_op->src[1] || gating_op->src[2]) {
+            return false;
+        }
+    } else if (gating_op->op == GGML_OP_UNARY) {
+        if (ggml_get_unary_op(gating_op) != GGML_UNARY_OP_SIGMOID) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// ported from ggml_cuda_topk_moe_fusion - pure graph inspection, backend-agnostic
+static bool ggml_sycl_topk_moe_fusion(const ggml_cgraph * cgraph, int node_idx, ggml_sycl_topk_moe_args & args) {
+    args = ggml_sycl_topk_moe_args{};
+
+    const int      n_nodes = cgraph->n_nodes;
+    ggml_tensor ** nodes   = cgraph->nodes;
+
+    if (nodes[node_idx]->op == GGML_OP_SOFT_MAX) {
+        args.softmax = true;
+    }
+
+    if (nodes[node_idx]->op == GGML_OP_UNARY) {
+        if (ggml_get_unary_op(nodes[node_idx]) != GGML_UNARY_OP_SIGMOID) {
+            return false;
+        }
+        args.sigmoid = true;
+    }
+
+    if (nodes[node_idx]->op == GGML_OP_ARGSORT) {
+        args.delayed_softmax = true;
+    }
+
+    node_idx++;
+
+    if (args.sigmoid || args.softmax) {
+        // SOFTMAX -> RESHAPE
+        if (node_idx >= n_nodes || nodes[node_idx]->op != GGML_OP_RESHAPE ||
+            nodes[node_idx]->src[0] != nodes[node_idx - 1]) {
+            return false;
+        }
+        ggml_tensor * probs_reshaped = nodes[node_idx];
+        node_idx++;
+
+        if (node_idx >= n_nodes) {
+            return false;
+        }
+
+        // src of bias add is the unreshaped probs (-2 instead of -1)
+        if (nodes[node_idx]->op == GGML_OP_ADD && nodes[node_idx]->src[0] == nodes[node_idx - 2]) {
+            args.prob_bias = true;
+            node_idx++;
+        }
+        // RESHAPE/ADD -> ARGSORT
+        if (node_idx >= n_nodes || nodes[node_idx]->op != GGML_OP_ARGSORT) {
+            return false;
+        }
+
+        if (args.prob_bias && nodes[node_idx]->src[0] != nodes[node_idx - 1]) {
+            return false;
+        } else if (!args.prob_bias && nodes[node_idx]->src[0] != nodes[node_idx - 2]) {
+            return false;
+        }
+
+        node_idx++;
+
+        // ARGSORT -> VIEW
+        if (node_idx >= n_nodes || nodes[node_idx]->op != GGML_OP_VIEW ||
+            nodes[node_idx]->src[0] != nodes[node_idx - 1]) {
+            return false;
+        }
+        node_idx++;
+
+        if (node_idx >= n_nodes || nodes[node_idx]->op != GGML_OP_GET_ROWS) {
+            return false;
+        }
+
+        // GET_ROWS
+        if (nodes[node_idx]->src[0] != probs_reshaped || nodes[node_idx]->src[1] != nodes[node_idx - 1]) {
+            return false;
+        }
+        node_idx++;
+    } else if (args.delayed_softmax) {
+        if (node_idx - 2 < 0) {
+            return false;
+        }
+        ggml_tensor * probs_reshaped = nodes[node_idx - 2];
+
+        // VIEW -> ARGSORT
+        if (node_idx >= n_nodes || nodes[node_idx]->op != GGML_OP_VIEW ||
+            nodes[node_idx]->src[0] != nodes[node_idx - 1]) {
+            return false;
+        }
+        node_idx++;
+
+        // GET_ROWS
+        if (node_idx >= n_nodes || nodes[node_idx]->src[1] != nodes[node_idx - 1] ||
+            nodes[node_idx]->src[0] != probs_reshaped) {
+            return false;
+        }
+        node_idx++;
+
+        static const std::vector<ggml_op> remaining_ops = { GGML_OP_RESHAPE, GGML_OP_SOFT_MAX, GGML_OP_RESHAPE };
+
+        for (const ggml_op op : remaining_ops) {
+            if (node_idx >= n_nodes || nodes[node_idx]->op != op || nodes[node_idx]->src[0] != nodes[node_idx - 1]) {
+                return false;
+            }
+            node_idx++;
+        }
+    }
+
+    // at this point we can check for norm + scale; everything is now at least valid up to the norm
+    if (node_idx >= n_nodes) {
+        return true;
+    }
+
+    if (nodes[node_idx]->op == GGML_OP_RESHAPE) {
+        // check RESHAPE -> SUM_ROWS -> CLAMP -> DIV -> RESHAPE
+        static const std::vector<ggml_op> norm_ops = { GGML_OP_RESHAPE, GGML_OP_SUM_ROWS, GGML_OP_CLAMP };
+
+        args.norm = true;
+        for (const ggml_op op : norm_ops) {
+            if (nodes[node_idx]->op == op && nodes[node_idx]->src[0] == nodes[node_idx - 1]) {
+                node_idx++;
+            } else {
+                args.norm = false;
+                return true;
+            }
+        }
+
+        // DIV <- CLAMP, RESHAPE
+        if (nodes[node_idx]->op != GGML_OP_DIV || nodes[node_idx]->src[1] != nodes[node_idx - 1] ||
+            nodes[node_idx]->src[0] != nodes[node_idx - 3]) {
+            args.norm = false;
+            return true;
+        }
+        node_idx++;
+
+        if (nodes[node_idx]->op != GGML_OP_RESHAPE || nodes[node_idx]->src[0] != nodes[node_idx - 1]) {
+            args.norm = false;
+            return true;
+        }
+        node_idx++;
+    }
+
+    if (nodes[node_idx]->op == GGML_OP_SCALE && nodes[node_idx]->src[0] == nodes[node_idx - 1]) {
+        args.scale = true;
+    }
+
+    return true;
+}
+
+// returns whether the write (out) nodes overwrite the read nodes in operation
+// ported from ggml_cuda_check_fusion_memory_ranges - pure pointer/range inspection
+static bool ggml_sycl_check_fusion_memory_ranges(const ggml_cgraph * cgraph, const int node_idx,
+                                                 const int node_count, const int * out_nodes, const int out_count,
+                                                 const bool is_topk_moe = false) {
+    auto nodes_overlap = [&](const ggml_tensor * a, const ggml_tensor * b) {
+        const int64_t a_start = (int64_t) a->data;
+        const int64_t a_end   = a_start + ggml_backend_buft_get_alloc_size(a->buffer->buft, a);
+
+        const int64_t b_start = (int64_t) b->data;
+        const int64_t b_end   = b_start + ggml_backend_buft_get_alloc_size(b->buffer->buft, b);
+
+        if ((b_start <= a_start && a_start < b_end) || (a_start <= b_start && b_start < a_end)) {
+            return true;
+        }
+
+        return false;
+    };
+
+    bool is_ok = true;
+    // exception for topk-moe, as each row is read entirely before writing
+    if (ggml_nrows(cgraph->nodes[node_idx]) == 1 && is_topk_moe) {
+        return true;
+    }
+
+    for (int i = 0; i < out_count; ++i) {
+        const ggml_tensor * dst = cgraph->nodes[out_nodes[i]];
+
+        for (int j = node_idx; j < node_idx + node_count; ++j) {
+            // loop over all srcs of all nodes in the fusion. If the src overlaps the destination and
+            // the src is not an intermediate node that's being elided, then disable fusion.
+            for (int src_idx = 0; src_idx < GGML_MAX_SRC; ++src_idx) {
+                const ggml_tensor * src = cgraph->nodes[j]->src[src_idx];
+
+                if (!src || src->op == GGML_OP_NONE) {
+                    continue;
+                }
+
+                if (nodes_overlap(dst, src)) {
+                    bool found = false;
+
+                    for (int k = node_idx; k < j; ++k) {
+                        if (cgraph->nodes[k] == src) {
+                            found = true;
+                            break;
+                        }
+                    }
+
+                    if (!found) {
+                        is_ok = false;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    return is_ok;
+}
+
+int ggml_sycl_fuse(ggml_backend_sycl_context & ctx, ggml_cgraph * cgraph, int i) {
+    if (!g_ggml_sycl_enable_fusion) {
+        return 0;
+    }
+
+    return ggml_sycl_fuse_topk_moe(ctx, cgraph, i);
+}
+
+int ggml_sycl_fuse_topk_moe(ggml_backend_sycl_context & ctx, ggml_cgraph * cgraph, int i) {
+    ggml_tensor * node = cgraph->nodes[i];
+
+    if (node->op != GGML_OP_UNARY && node->op != GGML_OP_SOFT_MAX && node->op != GGML_OP_ARGSORT) {
+        return 0;
+    }
+
+    ggml_sycl_topk_moe_args args;
+    if (!ggml_sycl_topk_moe_fusion(cgraph, i, args)) {
+        return 0;
+    }
+
+    // this kernel implements the no-bias path only; decline anything with a routing bias
+    if (args.prob_bias) {
+        return 0;
+    }
+
+    const ggml_tensor * logits  = node->src[0];
+    ggml_tensor *       weights = nullptr;
+    ggml_tensor *       ids     = nullptr;
+    const ggml_tensor * clamp   = nullptr;
+    const ggml_tensor * scale   = nullptr;
+
+    std::vector<ggml_op> ops;
+    int                  out_nodes[2];
+
+    if (!args.delayed_softmax) {
+        const ggml_op gating_op = args.sigmoid ? GGML_OP_UNARY : GGML_OP_SOFT_MAX;
+        ops.insert(ops.end(), { gating_op, GGML_OP_RESHAPE, GGML_OP_ARGSORT, GGML_OP_VIEW, GGML_OP_GET_ROWS });
+        out_nodes[0] = i + 3;
+        ids          = cgraph->nodes[i + 3];
+
+        if (args.norm) {
+            ops.insert(ops.end(), { GGML_OP_RESHAPE, GGML_OP_SUM_ROWS, GGML_OP_CLAMP, GGML_OP_DIV, GGML_OP_RESHAPE });
+            clamp = cgraph->nodes[i + (int) ops.size() - 3];
+        }
+        if (args.scale) {
+            ops.insert(ops.end(), { GGML_OP_SCALE });
+            scale = cgraph->nodes[i + (int) ops.size() - 1];
+        }
+
+        weights      = cgraph->nodes[i + (int) ops.size() - 1];
+        out_nodes[1] = i + (int) ops.size() - 1;
+
+        if (ggml_can_fuse_subgraph(cgraph, i, ops.size(), ops.data(), out_nodes, 2) &&
+            ggml_sycl_should_use_topk_moe(node, weights, logits, ids) &&
+            ggml_sycl_check_fusion_memory_ranges(cgraph, i, (int) ops.size(), out_nodes, 2, /*is_topk_moe=*/true)) {
+            ggml_sycl_op_topk_moe(ctx, logits, weights, ids, clamp, scale, args);
+            return (int) ops.size() - 1;
+        }
+    } else if (!args.norm && !args.prob_bias) {
+        // gpt-oss style: argsort -> view -> get_rows -> reshape -> softmax -> reshape, no norm/bias
+        ops.insert(ops.end(),
+                   { GGML_OP_ARGSORT, GGML_OP_VIEW, GGML_OP_GET_ROWS, GGML_OP_RESHAPE, GGML_OP_SOFT_MAX,
+                     GGML_OP_RESHAPE });
+        weights                     = cgraph->nodes[i + 5];
+        ids                         = cgraph->nodes[i + 1];
+        const ggml_tensor * softmax = cgraph->nodes[i + 4];
+        out_nodes[0]                = i + 1;
+        out_nodes[1]                = i + 5;
+
+        if (ggml_can_fuse_subgraph(cgraph, i, ops.size(), ops.data(), out_nodes, 2) &&
+            ggml_sycl_should_use_topk_moe(softmax, weights, logits, ids) &&
+            ggml_sycl_check_fusion_memory_ranges(cgraph, i, (int) ops.size(), out_nodes, 2, /*is_topk_moe=*/true)) {
+            ggml_sycl_op_topk_moe(ctx, logits, weights, ids, clamp, scale, args);
+            return (int) ops.size() - 1;
+        }
+    }
+
+    return 0;
+}

ggml/src/ggml-sycl/topk-moe.hpp

@@ -0,0 +1,12 @@
+#ifndef GGML_SYCL_TOPK_MOE_HPP
+#define GGML_SYCL_TOPK_MOE_HPP
+
+#include "common.hpp"
+
+// Detect a fusable op subgraph starting at cgraph node `i` and, if found, dispatch the fused
+// kernel. Returns the number of *following* nodes consumed (0 = no fusion applies at i).
+int ggml_sycl_fuse(ggml_backend_sycl_context & ctx, ggml_cgraph * cgraph, int i);
+
+int ggml_sycl_fuse_topk_moe(ggml_backend_sycl_context & ctx, ggml_cgraph * cgraph, int i);
+
+#endif  // GGML_SYCL_TOPK_MOE_HPP

tests/test-chat.cpp

@@ -4706,9 +4706,16 @@ static void test_template_output_peg_parsers(bool detailed_debug) {
     // Format: <TOOLCALL>[{"name": "func", "arguments": {...}}]</TOOLCALL>
     {
         auto tst = peg_tester("models/templates/NVIDIA-Nemotron-Nano-v2.jinja", detailed_debug);
-        tst.test("<TOOLCALL>[{\"name\": \"special_function\", \"arguments\": {\"arg1\": 1}}]</TOOLCALL>")
+        tst.test("I'm\nthinking\n</think>\n<TOOLCALL>[{\"name\": \"special_function\", \"arguments\": {\"arg1\": 1}}]</TOOLCALL>")
+            .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
             .tools({ special_function_tool })
-            .expect(message_assist_call)
+            .expect(message_assist_call_thoughts)
+            .run();
+
+        tst.test("I'm\nthinking\n</think>\n\n<TOOLCALL>[{\"name\": \"special_function\", \"arguments\": {\"arg1\": 1}}]</TOOLCALL>\n")
+            .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
+            .tools({ special_function_tool })
+            .expect(message_assist_call_thoughts)
             .run();
 
         // Continuation tests

tools/ui/src/lib/components/app/chat/ChatForm/ChatFormActions/ChatFormActionAdd/ChatFormActionAddMcpServersSubmenu.svelte

@@ -17,7 +17,7 @@
 	let { onMcpSettingsClick }: Props = $props();
 
 	let mcpSearchQuery = $state('');
-	let allMcpServers = $derived(mcpStore.getServersSorted());
+	let allMcpServers = $derived(mcpStore.getServers());
 	let mcpServers = $derived(mcpStore.visibleMcpServers);
 	let hasMcpServers = $derived(mcpServers.length > 0);
 	// let hasAnyMcpServers = $derived(allMcpServers.length > 0);

tools/ui/src/lib/components/app/chat/ChatForm/ChatFormActions/ChatFormActionAdd/ChatFormActionAddToolsSubmenu.svelte

@@ -10,7 +10,7 @@
 	import { useToolsPanel } from '$lib/hooks/use-tools-panel.svelte';
 
 	const toolsPanel = useToolsPanel();
-	const hasMcpServersAvailable = $derived(mcpStore.getServersSorted().length > 0);
+	const hasMcpServersAvailable = $derived(mcpStore.getServers().length > 0);
 </script>
 
 <DropdownMenu.Sub onOpenChange={(open) => open && toolsPanel.handleOpen()}>

tools/ui/src/lib/components/app/chat/ChatForm/ChatFormPickers/ChatFormPickerMcpPrompts/ChatFormPickerMcpPrompts.svelte

@@ -322,7 +322,7 @@
 	}
 
 	let filteredPrompts = $derived.by(() => {
-		const sortedServers = mcpStore.getServersSorted();
+		const sortedServers = mcpStore.getServers();
 		const serverOrderMap = new Map(sortedServers.map((server, index) => [server.id, index]));
 
 		const sortedPrompts = [...prompts].sort((a, b) => {

tools/ui/src/lib/components/app/chat/ChatForm/ChatFormPickers/ChatFormPickerMcpResources.svelte

@@ -138,7 +138,7 @@
 	}
 
 	let filteredResources = $derived.by(() => {
-		const sortedServers = mcpStore.getServersSorted();
+		const sortedServers = mcpStore.getServers();
 		const serverOrderMap = new Map(sortedServers.map((server, index) => [server.id, index]));
 
 		const sortedResources = [...resources].sort((a, b) => {

tools/ui/src/lib/components/app/dialogs/DialogMcpServerRecommendations.svelte

@@ -1,210 +0,0 @@
-<script lang="ts">
-	import { Button } from '$lib/components/ui/button';
-	import * as Card from '$lib/components/ui/card';
-	import * as Dialog from '$lib/components/ui/dialog';
-	import { fly } from 'svelte/transition';
-	import { McpServerCardCompact, McpServerForm } from '$lib/components/app/mcp';
-	import { RECOMMENDED_MCP_SERVERS, SETTINGS_KEYS } from '$lib/constants';
-	import { conversationsStore } from '$lib/stores/conversations.svelte';
-	import { mcpStore } from '$lib/stores/mcp.svelte';
-	import { settingsStore } from '$lib/stores/settings.svelte';
-	import { uuid } from '$lib/utils';
-	import { MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY, MCP_SERVER_ID_PREFIX } from '$lib/constants';
-	import type { MCPServerSettingsEntry } from '$lib/types';
-	import { Plus } from '@lucide/svelte';
-
-	interface Props {
-		open: boolean;
-		onOpenChange?: (open: boolean) => void;
-	}
-
-	let { open = $bindable(), onOpenChange }: Props = $props();
-
-	let selected = $state<Record<string, boolean>>(
-		Object.fromEntries(RECOMMENDED_MCP_SERVERS.map((server) => [server.id, false]))
-	);
-
-	let addedServers = $state<MCPServerSettingsEntry[]>([]);
-	let didAddAny = $state(false);
-
-	let selectedRecommendedCount = $derived.by(
-		() => RECOMMENDED_MCP_SERVERS.filter((server) => selected[server.id]).length
-	);
-
-	let footerLabel = $derived.by(() => {
-		const recommended = selectedRecommendedCount;
-		const custom = addedServers.length;
-		const total = recommended + custom;
-
-		if (total === 0) return 'Continue';
-		if (recommended === 0) return custom === 1 ? 'Add server' : `Add ${custom} servers`;
-		if (custom === 0) return recommended === 1 ? 'Add server' : `Add ${recommended} servers`;
-		return `Add ${recommended} servers and ${custom} custom`;
-	});
-
-	let showAddForm = $state(false);
-	let newServerUrl = $state('');
-	let newServerHeaders = $state('');
-	let newServerUrlError = $derived.by(() => {
-		if (!newServerUrl.trim()) return 'URL is required';
-		try {
-			new URL(newServerUrl);
-
-			return null;
-		} catch {
-			return 'Invalid URL format';
-		}
-	});
-
-	function handleOpenChange(value: boolean) {
-		if (!value) {
-			showAddForm = false;
-			newServerUrl = '';
-			newServerHeaders = '';
-
-			if (!didAddAny) {
-				settingsStore.updateConfig(SETTINGS_KEYS.MCP_SERVERS, []);
-			}
-
-			localStorage.setItem(MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY, 'true');
-			addedServers = [];
-			didAddAny = false;
-		}
-		open = value;
-		onOpenChange?.(value);
-	}
-
-	function resetAddForm() {
-		showAddForm = false;
-		newServerUrl = '';
-		newServerHeaders = '';
-	}
-
-	function enableSelected() {
-		didAddAny = true;
-		localStorage.setItem(MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY, 'true');
-
-		for (const server of RECOMMENDED_MCP_SERVERS) {
-			if (selected[server.id]) {
-				const existing = mcpStore.getServerById(server.id);
-				if (existing) {
-					mcpStore.updateServer(server.id, { enabled: true });
-				} else {
-					mcpStore.addServer({
-						id: server.id,
-						enabled: true,
-						url: server.url,
-						name: server.name
-					});
-				}
-				conversationsStore.setMcpServerOverride(server.id, true);
-			}
-		}
-		handleOpenChange(false);
-	}
-
-	function saveNewServer() {
-		if (newServerUrlError) return;
-
-		didAddAny = true;
-
-		const newServerId = uuid() ?? `${MCP_SERVER_ID_PREFIX}-${Date.now()}`;
-
-		localStorage.setItem(MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY, 'true');
-
-		const newServer = mcpStore.addServer({
-			id: newServerId,
-			enabled: true,
-			url: newServerUrl.trim(),
-			headers: newServerHeaders.trim() || undefined
-		});
-
-		conversationsStore.setMcpServerOverride(newServerId, true);
-
-		if (newServer) {
-			addedServers = [...addedServers, newServer];
-		}
-
-		resetAddForm();
-	}
-</script>
-
-<Dialog.Root bind:open onOpenChange={handleOpenChange}>
-	<Dialog.Content class="sm:max-w-lg">
-		<Dialog.Header>
-			<Dialog.Title>Do more with MCP</Dialog.Title>
-			<Dialog.Description>
-				Power-up your experience by adding tools, resources and more capabilities provided by MCP
-				servers.
-			</Dialog.Description>
-		</Dialog.Header>
-
-		<div class="max-h-[60vh] space-y-4 overflow-y-auto py-4" in:fly={{ y: 16, duration: 300 }}>
-			<h3 class="text-sm font-semibold">Quickly get started with</h3>
-
-			{#each RECOMMENDED_MCP_SERVERS as server (server.id)}
-				<McpServerCardCompact
-					{server}
-					enabled={selected[server.id]}
-					onToggle={(enabled) => (selected[server.id] = enabled)}
-				/>
-			{/each}
-
-			{#if addedServers.length > 0}
-				{#each addedServers as server (server.id)}
-					<McpServerCardCompact {server} enabled={true} />
-				{/each}
-			{/if}
-
-			{#if showAddForm}
-				<Card.Root class="gap-3! bg-muted/30 p-4">
-					<McpServerForm
-						url={newServerUrl}
-						headers={newServerHeaders}
-						onUrlChange={(v) => (newServerUrl = v)}
-						onHeadersChange={(v) => (newServerHeaders = v)}
-						urlError={newServerUrl ? newServerUrlError : null}
-						id="recommendation-new-server"
-					/>
-
-					<div class="flex justify-end gap-2 pt-2">
-						<Button variant="secondary" size="sm" onclick={resetAddForm}>Cancel</Button>
-
-						<Button
-							variant="default"
-							size="sm"
-							onclick={saveNewServer}
-							disabled={!!newServerUrlError}
-							aria-label="Save"
-						>
-							Add
-						</Button>
-					</div>
-				</Card.Root>
-			{:else}
-				<Card.Root class="gap-0 border-dashed bg-muted/30 p-0 transition-colors hover:bg-muted/50">
-					<button
-						type="button"
-						class="flex w-full items-center justify-center gap-2 rounded-lg p-6 text-sm text-muted-foreground transition-colors hover:text-foreground"
-						onclick={() => (showAddForm = true)}
-						aria-label="Add your own MCP server"
-					>
-						<Plus class="h-4 w-4" />
-						<span>Add your own server</span>
-					</button>
-				</Card.Root>
-			{/if}
-		</div>
-
-		<Dialog.Footer>
-			<Button variant="secondary" size="sm" onclick={() => handleOpenChange(false)}>Not now</Button>
-
-			<Button
-				variant="default"
-				size="sm"
-				onclick={enableSelected}
-				disabled={footerLabel === 'Continue'}>{footerLabel}</Button
-			>
-		</Dialog.Footer>
-	</Dialog.Content>
-</Dialog.Root>

tools/ui/src/lib/components/app/dialogs/index.ts

@@ -18,15 +18,6 @@
  */
 export { default as DialogMcpServerAddNew } from './DialogMcpServerAddNew.svelte';
 
-/**
- * **DialogMcpServerRecommendations** - Suggested MCP servers opt-in dialog
- *
- * Prompts the user to enable pre-defined recommended MCP servers on first launch.
- * Shows one switch per suggested server and persists the choice as a per-chat
- * override so the selected servers become available in conversations.
- */
-export { default as DialogMcpServerRecommendations } from './DialogMcpServerRecommendations.svelte';
-
 /**
  * **DialogExportSettings** - Settings export dialog with sensitive data warning
  *

tools/ui/src/lib/components/app/mcp/McpActiveServersAvatars.svelte

@@ -13,7 +13,7 @@
 
 	let { class: className = '', onclick }: Props = $props();
 
-	let mcpServers = $derived(mcpStore.getServersSorted().filter((s) => s.enabled));
+	let mcpServers = $derived(mcpStore.getServers().filter((s) => s.enabled));
 	let enabledMcpServersForChat = $derived(
 		mcpServers.filter((s) => conversationsStore.isMcpServerEnabledForChat(s.id) && s.url.trim())
 	);

tools/ui/src/lib/components/app/mcp/McpServerCard/McpServerCardCompact.svelte

@@ -1,156 +0,0 @@
-<script lang="ts">
-	import * as Card from '$lib/components/ui/card';
-	import { Badge } from '$lib/components/ui/badge';
-	import { Skeleton } from '$lib/components/ui/skeleton';
-	import { Switch } from '$lib/components/ui/switch';
-	import * as Tooltip from '$lib/components/ui/tooltip';
-	import { McpServerIdentity } from '$lib/components/app/mcp';
-	import { mcpStore } from '$lib/stores/mcp.svelte';
-	import { HealthCheckStatus } from '$lib/enums';
-	import type { MCPServerDisplayInfo, HealthCheckState, MCPServerSettingsEntry } from '$lib/types';
-	import { onMount } from 'svelte';
-	import { MCP_CARD_VISIBLE_TOOL_LIMIT, NEWLINE } from '$lib/constants';
-
-	interface Props {
-		server: MCPServerDisplayInfo & { description?: string };
-		enabled?: boolean;
-		onToggle?: (enabled: boolean) => void;
-	}
-
-	let { server, enabled = false, onToggle }: Props = $props();
-
-	onMount(() => {
-		const state = mcpStore.getHealthCheckState(server.id);
-
-		if (state.status === HealthCheckStatus.IDLE) {
-			mcpStore.runHealthCheck(server as MCPServerSettingsEntry).catch(() => {});
-		}
-	});
-
-	let healthState = $derived<HealthCheckState>(mcpStore.getHealthCheckState(server.id));
-	let displayName = $derived(mcpStore.getServerLabel(server));
-	let faviconUrl = $derived(mcpStore.getServerFavicon(server.id));
-	let isIdle = $derived(healthState.status === HealthCheckStatus.IDLE);
-	let isHealthChecking = $derived(healthState.status === HealthCheckStatus.CONNECTING);
-	let isError = $derived(healthState.status === HealthCheckStatus.ERROR);
-	let errorMessage = $derived(
-		healthState.status === HealthCheckStatus.ERROR ? healthState.message : undefined
-	);
-	let serverInfo = $derived(
-		healthState.status === HealthCheckStatus.SUCCESS ? healthState.serverInfo : undefined
-	);
-	let tools = $derived(healthState.status === HealthCheckStatus.SUCCESS ? healthState.tools : []);
-	let instructions = $derived(
-		healthState.status === HealthCheckStatus.SUCCESS ? healthState.instructions : undefined
-	);
-	let showSkeleton = $derived(isIdle || isHealthChecking);
-
-	// Curated descriptions get two lines; instructions fallback is one line so the
-	// compact card stays scannable.
-	let description = $derived.by(() => {
-		if (server.description) {
-			return { text: server.description, lines: 2 };
-		}
-		if (!instructions) return null;
-		const firstLine = instructions.split(NEWLINE).find((line: string) => line.trim().length > 0);
-		const trimmed = firstLine?.trim();
-		return trimmed ? { text: trimmed, lines: 1 } : null;
-	});
-
-	let visibleTools = $derived(tools.slice(0, MCP_CARD_VISIBLE_TOOL_LIMIT));
-	let hiddenTools = $derived(tools.slice(MCP_CARD_VISIBLE_TOOL_LIMIT));
-	let hiddenToolCount = $derived(hiddenTools.length);
-
-	function handleToggle(checked: boolean) {
-		onToggle?.(checked);
-	}
-</script>
-
-<Card.Root class="!gap-3 bg-muted/30 p-4">
-	<div class="flex items-start justify-between gap-3">
-		<div class="min-w-0 flex-1">
-			{#if showSkeleton}
-				<span class="flex min-w-0 items-center gap-1.5">
-					<Skeleton class="h-5 w-5 rounded" />
-					<Skeleton class="h-4 w-32" />
-				</span>
-			{:else}
-				<McpServerIdentity
-					{displayName}
-					{faviconUrl}
-					{serverInfo}
-					iconClass="h-5 w-5"
-					iconRounded="rounded"
-					nameClass="font-medium"
-				/>
-			{/if}
-		</div>
-
-		<Switch checked={enabled} disabled={isError || showSkeleton} onCheckedChange={handleToggle} />
-	</div>
-
-	{#if isError && errorMessage}
-		<p class="text-xs text-destructive">{errorMessage}</p>
-	{/if}
-
-	{#if showSkeleton}
-		<div class="space-y-1.5">
-			<Skeleton class="h-3 w-full max-w-md" />
-		</div>
-
-		<div class="flex flex-wrap items-center gap-1.5">
-			<Skeleton class="h-5 w-16 rounded-full" />
-			<Skeleton class="h-5 w-20 rounded-full" />
-			<Skeleton class="h-5 w-24 rounded-full" />
-			<Skeleton class="h-5 w-14 rounded-full" />
-		</div>
-	{:else}
-		{#if description}
-			{#if description.lines === 2}
-				<p class="line-clamp-2 text-xs text-muted-foreground" title={description.text}>
-					{description.text}
-				</p>
-			{:else}
-				<p class="line-clamp-1 truncate text-xs text-muted-foreground" title={description.text}>
-					{description.text}
-				</p>
-			{/if}
-		{/if}
-
-		{#if tools.length > 0}
-			<div class="flex flex-wrap items-center gap-1.5">
-				{#each visibleTools as tool (tool.name)}
-					<Tooltip.Root>
-						<Tooltip.Trigger>
-							<Badge variant="secondary" class="h-5 max-w-40 px-2 text-[11px]">
-								<span class="block min-w-0 flex-1 truncate">{tool.name}</span>
-							</Badge>
-						</Tooltip.Trigger>
-
-						<Tooltip.Content>
-							<p class="max-w-xs text-xs">
-								{tool.description ?? 'No description'}
-							</p>
-						</Tooltip.Content>
-					</Tooltip.Root>
-				{/each}
-
-				{#if hiddenToolCount > 0}
-					<Tooltip.Root>
-						<Tooltip.Trigger>
-							<Badge variant="secondary" class="h-5 px-2 text-[11px] text-muted-foreground">
-								+ {hiddenToolCount} more tools
-							</Badge>
-						</Tooltip.Trigger>
-
-						<Tooltip.Content class="max-w-md">
-							<p class="text-xs">
-								{hiddenTools.map((tool) => tool.name).join(', ')}
-							</p>
-						</Tooltip.Content>
-					</Tooltip.Root>
-				{/if}
-			</div>
-		{/if}
-	{/if}
-</Card.Root>

tools/ui/src/lib/components/app/mcp/index.ts

@@ -180,16 +180,6 @@ export { default as McpServerCardDeleteDialog } from './McpServerCard/McpServerC
 /** Skeleton loading state for server card during health checks. */
 export { default as McpServerCardSkeleton } from './McpServerCardSkeleton.svelte';
 
-/**
- * **McpServerCardCompact** - Condensed MCP server card
- *
- * Compact alternative to McpServerCard tailored for picker-style UIs.
- * Shows the server identity, status, and a flex-wrapped list of available tools.
- * Tool names are rendered as badges; hovering a badge shows its description in a tooltip.
- * Does not show connection logs or server instructions.
- */
-export { default as McpServerCardCompact } from './McpServerCard/McpServerCardCompact.svelte';
-
 /**
  * **McpServerIdentity** - Server identity display (icon, name, version)
  *

tools/ui/src/lib/components/app/settings/SettingsMcpServers.svelte

@@ -1,9 +1,10 @@
 <script lang="ts">
 	import { X, Plus } from '@lucide/svelte';
-	import { Button } from '$lib/components/ui/button';
 	import { mcpStore } from '$lib/stores/mcp.svelte';
 	import { conversationsStore } from '$lib/stores/conversations.svelte';
 	import { toolsStore } from '$lib/stores/tools.svelte';
+	import { Button } from '$lib/components/ui/button';
+	import * as Empty from '$lib/components/ui/empty';
 	import { ActionIcon, McpServerCard, McpServerCardSkeleton } from '$lib/components/app';
 	import { DialogMcpServerAddNew } from '$lib/components/app/dialogs';
 	import { HealthCheckStatus } from '$lib/enums';
@@ -23,7 +24,6 @@
 
 	let servers = $derived(mcpStore.visibleMcpServers);
 
-	let initialLoadComplete = $state(false);
 	let isAddingServer = $state(false);
 
 	let previousRouteId = $state<string | null>(null);
@@ -55,26 +55,16 @@
 		}
 	});
 
-	$effect(() => {
-		if (initialLoadComplete) return;
-
-		const allChecked =
-			servers.length > 0 &&
-			servers.every((server) => {
-				const state = mcpStore.getHealthCheckState(server.id);
-
-				return (
-					state.status === HealthCheckStatus.SUCCESS || state.status === HealthCheckStatus.ERROR
-				);
-			});
-
-		if (allChecked) {
-			initialLoadComplete = true;
-		}
-	});
+	// Each card decides for itself whether to render based on its own
+	// health-check state, so adding a server only flashes the new card
+	// (not every other already-loaded card) until its health check resolves.
+	function isServerPending(serverId: string): boolean {
+		const status = mcpStore.getHealthCheckState(serverId).status;
+		return status === HealthCheckStatus.IDLE || status === HealthCheckStatus.CONNECTING;
+	}
 </script>
 
-<div in:fade={{ duration: 150 }}>
+<div in:fade={{ duration: 150 }} class="flex min-h-[calc(100dvh-4rem)] flex-col">
 	<div class="fixed top-4.5 right-4 z-50 md:hidden">
 		<ActionIcon icon={X} tooltip="Close" onclick={handleClose} />
 	</div>
@@ -87,53 +77,78 @@
 
 			<h1 class="text-lg font-semibold md:text-2xl">MCP Servers</h1>
 		</div>
-
-		<Button
-			variant="outline"
-			size="lg"
-			class="shrink-0 fixed md:static bottom-6 right-6"
-			onclick={() => (isAddingServer = true)}
-		>
-			<Plus class="h-4 w-4" />
-
-			Add New Server
-		</Button>
 	</div>
 
 	<DialogMcpServerAddNew bind:open={isAddingServer} />
 
-	<div class="grid gap-5 md:space-y-4 {className}">
-		{#if servers.length === 0 && !isAddingServer}
-			<div class="rounded-md border border-dashed p-4 text-sm text-muted-foreground">
-				No MCP Servers configured yet. Add one to enable agentic features.
-			</div>
-		{/if}
+	{#if servers.length === 0}
+		<div class="flex flex-1 items-center justify-center py-16">
+			<Empty.Root class="max-w-md">
+				<Empty.Header>
+					<Empty.Media variant="icon">
+						<Plus />
+					</Empty.Media>
 
-		{#if servers.length > 0}
-			<div
-				class="grid gap-3"
-				style="grid-template-columns: repeat(auto-fill, minmax(min(32rem, calc(100dvw - 2rem)), 1fr));"
-			>
-				{#each servers as server (server.id)}
-					{#if !initialLoadComplete}
-						<McpServerCardSkeleton />
-					{:else}
-						<McpServerCard
-							{server}
-							enabled={conversationsStore.isMcpServerEnabledForChat(server.id)}
-							onToggle={async () => {
-								const wasEnabled = conversationsStore.isMcpServerEnabledForChat(server.id);
-								await conversationsStore.toggleMcpServerForChat(server.id);
-								if (!wasEnabled) {
-									toolsStore.enableAllToolsForServer(server.id);
-								}
-							}}
-							onUpdate={(updates) => mcpStore.updateServer(server.id, updates)}
-							onDelete={() => mcpStore.removeServer(server.id)}
-						/>
-					{/if}
-				{/each}
-			</div>
-		{/if}
-	</div>
+					<Empty.Title>Add your first MCP server</Empty.Title>
+
+					<Empty.Description>Connect a remote MCP server by URL.</Empty.Description>
+				</Empty.Header>
+
+				<Empty.Content>
+					<Button size="sm" onclick={() => (isAddingServer = true)}>
+						<Plus />
+
+						Add New Server
+					</Button>
+				</Empty.Content>
+			</Empty.Root>
+		</div>
+	{:else}
+		<div
+			class="grid gap-3 {className}"
+			style="grid-template-columns: repeat(auto-fill, minmax(min(32rem, calc(100dvw - 2rem)), 1fr));"
+		>
+			{#each servers as server (server.id)}
+				{#if isServerPending(server.id)}
+					<McpServerCardSkeleton />
+				{:else}
+					<McpServerCard
+						{server}
+						enabled={conversationsStore.isMcpServerEnabledForChat(server.id)}
+						onToggle={async () => {
+							const wasEnabled = conversationsStore.isMcpServerEnabledForChat(server.id);
+							await conversationsStore.toggleMcpServerForChat(server.id);
+							if (!wasEnabled) {
+								toolsStore.enableAllToolsForServer(server.id);
+							}
+						}}
+						onUpdate={(updates) => mcpStore.updateServer(server.id, updates)}
+						onDelete={() => mcpStore.removeServer(server.id)}
+					/>
+				{/if}
+			{/each}
+
+			{#if !isAddingServer}
+				<Empty.Root class="border">
+					<Empty.Header>
+						<Empty.Media variant="icon">
+							<Plus />
+						</Empty.Media>
+
+						<Empty.Title>Add another MCP server</Empty.Title>
+
+						<Empty.Description>Connect a remote MCP server by URL.</Empty.Description>
+					</Empty.Header>
+
+					<Empty.Content>
+						<Button size="sm" onclick={() => (isAddingServer = true)}>
+							<Plus />
+
+							Add New Server
+						</Button>
+					</Empty.Content>
+				</Empty.Root>
+			{/if}
+		</div>
+	{/if}
 </div>

tools/ui/src/lib/components/ui/empty/empty-content.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+	import { cn, type WithElementRef } from '$lib/components/ui/utils.js';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	let {
+		ref = $bindable(null),
+		class: className,
+		children,
+		...restProps
+	}: WithElementRef<HTMLAttributes<HTMLDivElement>> = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="empty-content"
+	class={cn(
+		'gap-2.5 text-sm flex w-full max-w-sm min-w-0 flex-col items-center text-balance',
+		className
+	)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

tools/ui/src/lib/components/ui/empty/empty-description.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+	import { cn, type WithElementRef } from '$lib/components/ui/utils.js';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	let {
+		ref = $bindable(null),
+		class: className,
+		children,
+		...restProps
+	}: WithElementRef<HTMLAttributes<HTMLDivElement>> = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="empty-description"
+	class={cn(
+		'text-sm/relaxed text-muted-foreground [&>a:hover]:text-primary text-sm/relaxed [&>a]:underline [&>a]:underline-offset-4',
+		className
+	)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

tools/ui/src/lib/components/ui/empty/empty-header.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+	import { cn, type WithElementRef } from '$lib/components/ui/utils.js';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	let {
+		ref = $bindable(null),
+		class: className,
+		children,
+		...restProps
+	}: WithElementRef<HTMLAttributes<HTMLDivElement>> = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="empty-header"
+	class={cn('gap-2 flex max-w-sm flex-col items-center', className)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

tools/ui/src/lib/components/ui/empty/empty-media.svelte

@@ -0,0 +1,41 @@
+<script lang="ts" module>
+	import { tv, type VariantProps } from 'tailwind-variants';
+
+	export const emptyMediaVariants = tv({
+		base: 'mb-2 flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:shrink-0',
+		variants: {
+			variant: {
+				default: 'bg-transparent',
+				icon: "bg-muted text-foreground flex size-8 shrink-0 items-center justify-center rounded-lg [&_svg:not([class*='size-'])]:size-4"
+			}
+		},
+		defaultVariants: {
+			variant: 'default'
+		}
+	});
+
+	export type EmptyMediaVariant = VariantProps<typeof emptyMediaVariants>['variant'];
+</script>
+
+<script lang="ts">
+	import { cn, type WithElementRef } from '$lib/components/ui/utils.js';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	let {
+		ref = $bindable(null),
+		class: className,
+		children,
+		variant = 'default',
+		...restProps
+	}: WithElementRef<HTMLAttributes<HTMLDivElement>> & { variant?: EmptyMediaVariant } = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="empty-icon"
+	data-variant={variant}
+	class={cn(emptyMediaVariants({ variant }), className)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

tools/ui/src/lib/components/ui/empty/empty-title.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+	import { cn, type WithElementRef } from '$lib/components/ui/utils.js';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	let {
+		ref = $bindable(null),
+		class: className,
+		children,
+		...restProps
+	}: WithElementRef<HTMLAttributes<HTMLDivElement>> = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="empty-title"
+	class={cn('text-sm font-medium tracking-tight', className)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

tools/ui/src/lib/components/ui/empty/empty.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+	import { cn, type WithElementRef } from '$lib/components/ui/utils.js';
+	import type { HTMLAttributes } from 'svelte/elements';
+
+	let {
+		ref = $bindable(null),
+		class: className,
+		children,
+		...restProps
+	}: WithElementRef<HTMLAttributes<HTMLDivElement>> = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="empty"
+	class={cn(
+		'gap-4 rounded-xl border-dashed p-6 flex w-full min-w-0 flex-1 flex-col items-center justify-center text-center text-balance',
+		className
+	)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

tools/ui/src/lib/components/ui/empty/index.ts

@@ -0,0 +1,22 @@
+import Root from './empty.svelte';
+import Header from './empty-header.svelte';
+import Media from './empty-media.svelte';
+import Title from './empty-title.svelte';
+import Description from './empty-description.svelte';
+import Content from './empty-content.svelte';
+
+export {
+	Root,
+	Header,
+	Media,
+	Title,
+	Description,
+	Content,
+	//
+	Root as Empty,
+	Header as EmptyHeader,
+	Media as EmptyMedia,
+	Title as EmptyTitle,
+	Description as EmptyDescription,
+	Content as EmptyContent
+};

tools/ui/src/lib/constants/index.ts

@@ -8,7 +8,6 @@ export * from './attachment-labels';
 export * from './database';
 export * from './reasoning-effort';
 export * from './reasoning-effort-tokens';
-export * from './recommended-mcp-servers';
 export * from './storage';
 export * from './attachment-menu';
 export * from './auto-scroll';

tools/ui/src/lib/constants/mcp-form.ts

@@ -1,4 +1,2 @@
 export const MCP_SERVER_URL_PLACEHOLDER = 'https://mcp.example.com/sse';
 export const MIN_AUTOCOMPLETE_INPUT_LENGTH = 1;
-/** Number of tools shown on the compact MCP server card before collapsing to a "+ N more" badge */
-export const MCP_CARD_VISIBLE_TOOL_LIMIT = 4;

tools/ui/src/lib/constants/recommended-mcp-servers.ts

@@ -1,35 +0,0 @@
-import { DEFAULT_MCP_CONFIG } from './mcp';
-import type { RecommendedMCPServer } from '$lib/types';
-
-/**
- * Pre-defined recommended MCP servers.
- *
- * Servers are enabled by default, but they are not turned on for individual
- * conversations until the user explicitly enables them (so their tools are
- * disabled by default).
- */
-export const RECOMMENDED_MCP_SERVERS: RecommendedMCPServer[] = [
-	{
-		id: 'exa-web-search',
-		name: 'Exa Web Search',
-		description: 'Search the web and retrieve relevant content.',
-		url: 'https://mcp.exa.ai/mcp',
-		enabled: true,
-		requestTimeoutSeconds: DEFAULT_MCP_CONFIG.requestTimeoutSeconds
-	},
-	{
-		id: 'huggingface-mcp',
-		name: 'Hugging Face',
-		description:
-			'Browse models, datasets, spaces and machine learning papers from the Hugging Face hub.',
-		url: 'https://huggingface.co/mcp',
-		enabled: true,
-		requestTimeoutSeconds: DEFAULT_MCP_CONFIG.requestTimeoutSeconds
-	}
-];
-
-export const RECOMMENDED_MCP_SERVER_IDS = new Set(
-	RECOMMENDED_MCP_SERVERS.map((server) => server.id)
-);
-
-export const RECOMMENDED_MCP_SERVERS_OPTIN_DIALOG_DELAY = 1000;

tools/ui/src/lib/constants/settings-keys.ts

@@ -58,7 +58,6 @@ export const SETTINGS_KEYS = {
 	// MCP
 	MCP_SERVERS: 'mcpServers',
 	MCP_REQUEST_TIMEOUT_SECONDS: 'mcpRequestTimeoutSeconds',
-	MCP_DEFAULT_SERVER_OVERRIDES: 'mcpDefaultServerOverrides',
 	AGENTIC_MAX_TURNS: 'agenticMaxTurns',
 	AGENTIC_MAX_TOOL_PREVIEW_LINES: 'agenticMaxToolPreviewLines',
 	SHOW_TOOL_CALL_IN_PROGRESS: 'showToolCallInProgress',

tools/ui/src/lib/constants/settings-registry.ts

@@ -28,7 +28,6 @@ import McpLogo from '$lib/components/app/mcp/McpLogo.svelte';
 import { SETTINGS_KEYS } from './settings-keys';
 import { ROUTES, SETTINGS_SECTION_SLUGS } from './routes';
 import { TITLE_GENERATION } from './title-generation';
-import { RECOMMENDED_MCP_SERVERS } from './recommended-mcp-servers';
 
 export const SETTINGS_SECTION_TITLES = {
 	GENERAL: 'General',
@@ -775,16 +774,9 @@ const NON_UI_SETTINGS: SettingsEntry[] = [
 		key: SETTINGS_KEYS.MCP_SERVERS,
 		label: 'MCP servers',
 		help: 'Configure MCP servers as a JSON list. Use the form in the MCP Client settings section to edit.',
-		defaultValue: JSON.stringify(RECOMMENDED_MCP_SERVERS),
+		defaultValue: '[]',
 		type: SettingsFieldType.INPUT,
 		sync: { serverKey: SETTINGS_KEYS.MCP_SERVERS, paramType: SyncableParameterType.STRING }
-	},
-	{
-		key: SETTINGS_KEYS.MCP_DEFAULT_SERVER_OVERRIDES,
-		label: 'MCP default server overrides',
-		help: 'Per-server enable/disable defaults inherited by new chats. JSON-serialized list of {serverId, enabled} entries.',
-		defaultValue: '[]',
-		type: SettingsFieldType.INPUT
 	}
 	// {
 	// 	key: SETTINGS_KEYS.PY_INTERPRETER_ENABLED,

tools/ui/src/lib/constants/storage.ts

@@ -22,8 +22,6 @@ export const DISABLED_TOOLS_LOCALSTORAGE_KEY = `${STORAGE_APP_NAME}.disabledTool
 export const DISABLED_TOOL_KEYS_LOCALSTORAGE_KEY = `${STORAGE_APP_NAME}.disabledToolKeys`;
 export const FAVORITE_MODELS_LOCALSTORAGE_KEY = `${STORAGE_APP_NAME}.favoriteModels`;
 export const REASONING_EFFORT_DEFAULT_LOCALSTORAGE_KEY = `${STORAGE_APP_NAME}.reasoningEffortDefault`;
-/** Set when user has interacted with the MCP server recommendations dialog (checked servers, added custom server, or dismissed) */
-export const MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY = `${STORAGE_APP_NAME}.mcpServersSetupDone`;
 export const USER_OVERRIDES_LOCALSTORAGE_KEY = `${STORAGE_APP_NAME}.userOverrides`;
 
 /** Key prefix for per-conversation resumable stream state, conversationId is appended */

tools/ui/src/lib/hooks/use-mcp-recommendations.svelte.ts

@@ -1,80 +0,0 @@
-import { browser } from '$app/environment';
-import {
-	MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY,
-	RECOMMENDED_MCP_SERVER_IDS,
-	RECOMMENDED_MCP_SERVERS_OPTIN_DIALOG_DELAY
-} from '$lib/constants';
-import { mcpStore } from '$lib/stores/mcp.svelte';
-
-/**
- * First-run opt-in dialog for the recommended MCP servers.
- *
- * Owns the dismissed / open / trigger-timeout state and the effect that
- * schedules the dialog. Reads opt-in status and the configured server list
- * from `mcpStore`, so callers don't need to recompute on their side.
- */
-export function useMcpRecommendations() {
-	let dismissed = $state(
-		browser && localStorage.getItem(MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY) === 'true'
-	);
-	let open = $state(false);
-	let checked = $state(false);
-	let triggerTimeout: ReturnType<typeof setTimeout> | null = null;
-
-	function dismiss() {
-		if (browser) {
-			localStorage.setItem(MCP_SERVERS_ADDED_TO_CHAT_LOCALSTORAGE_KEY, 'true');
-		}
-		dismissed = true;
-		open = false;
-		if (triggerTimeout) {
-			clearTimeout(triggerTimeout);
-			triggerTimeout = null;
-		}
-	}
-
-	function handleOpenChange(next: boolean) {
-		open = next;
-		if (!next) dismiss();
-	}
-
-	$effect(() => {
-		if (!browser) return;
-
-		if (open || dismissed) {
-			if (triggerTimeout) {
-				clearTimeout(triggerTimeout);
-				triggerTimeout = null;
-			}
-			return;
-		}
-
-		// Already evaluated once this session; leave any pending trigger alone so
-		// it can still fire later. Setting `checked = true` below re-runs this
-		// effect, and we must not wipe the timeout that was just scheduled.
-		if (checked) return;
-
-		const hasRecommendations = mcpStore
-			.getServers()
-			.some((server) => RECOMMENDED_MCP_SERVER_IDS.has(server.id));
-
-		if (hasRecommendations) {
-			triggerTimeout = setTimeout(() => {
-				open = true;
-			}, RECOMMENDED_MCP_SERVERS_OPTIN_DIALOG_DELAY);
-		}
-
-		checked = true;
-	});
-
-	return {
-		get open() {
-			return open;
-		},
-		get dismissed() {
-			return dismissed;
-		},
-		dismiss,
-		handleOpenChange
-	};
-}

tools/ui/src/lib/hooks/use-tools-panel.svelte.ts

@@ -95,7 +95,7 @@ export function useToolsPanel(): UseToolsPanelReturn {
 		if (toolsStore.builtinTools.length === 0 && !toolsStore.loading) {
 			toolsStore.fetchBuiltinTools();
 		}
-		mcpStore.runHealthChecksForServers(mcpStore.getServersSorted().filter((s) => s.enabled));
+		mcpStore.runHealthChecksForServers(mcpStore.getServers().filter((s) => s.enabled));
 	}
 
 	return {

tools/ui/src/lib/services/migration.service.ts

@@ -522,7 +522,7 @@ const mcpDefaultEnabledMigration: Migration = {
 		const config = configRaw ? JSON.parse(configRaw) : {};
 
 		// Don't overwrite an existing config entry — current data wins.
-		if (SETTINGS_KEYS.MCP_DEFAULT_SERVER_OVERRIDES in config) {
+		if (MCP_DEFAULT_OVERRIDES_LEGACY_KEY in config) {
 			if (import.meta.env.DEV && import.meta.env.VITE_DEBUG)
 				console.log('[Migration] MCP default enabled: config already has overrides, skipping');
 			return;
@@ -543,7 +543,7 @@ const mcpDefaultEnabledMigration: Migration = {
 			return;
 		}
 
-		config[SETTINGS_KEYS.MCP_DEFAULT_SERVER_OVERRIDES] = raw;
+		config[MCP_DEFAULT_OVERRIDES_LEGACY_KEY] = raw;
 		localStorage.setItem(CONFIG_LOCALSTORAGE_KEY, JSON.stringify(config));
 
 		if (import.meta.env.DEV && import.meta.env.VITE_DEBUG)
@@ -586,6 +586,83 @@ const configTypesMigration: Migration = {
 	}
 };
 
+const MCP_DEFAULT_OVERRIDES_LEGACY_KEY = `${STORAGE_APP_NAME}.mcpDefaultServerOverrides`;
+const MCP_DEFAULT_OVERRIDES_MERGE_MIGRATION_ID = 'mcp-default-overrides-merge-v1';
+
+/**
+ * Folds `mcpDefaultServerOverrides` (the legacy "default for new chats" list,
+ * JSON-encoded as `[{ serverId, enabled }, ...]`) into `mcpServers[i].enabled`.
+ * The legacy override key is intentionally left in the config so a downgrade
+ * keeps reading it. Runs after `mcpDefaultEnabledMigration` so any legacy
+ * standalone overrides are already inside the config.
+ */
+const mcpDefaultOverridesMergeMigration: Migration = {
+	id: MCP_DEFAULT_OVERRIDES_MERGE_MIGRATION_ID,
+	description:
+		'Merge mcpDefaultServerOverrides entries onto mcpServers[i].enabled (preserves legacy key)',
+
+	async run(): Promise<void> {
+		const configRaw = localStorage.getItem(CONFIG_LOCALSTORAGE_KEY);
+		if (configRaw === null) return;
+
+		const config = JSON.parse(configRaw);
+		const raw = config[MCP_DEFAULT_OVERRIDES_LEGACY_KEY];
+
+		if (typeof raw !== 'string' || raw.length === 0) {
+			if (import.meta.env.DEV && import.meta.env.VITE_DEBUG)
+				console.log('[Migration] MCP default overrides merge: nothing to merge');
+			return;
+		}
+
+		let overrides: { serverId: string; enabled: boolean }[];
+		try {
+			const parsed = JSON.parse(raw);
+			if (!Array.isArray(parsed)) return;
+			overrides = parsed.filter(
+				(o) =>
+					typeof o === 'object' &&
+					o !== null &&
+					typeof (o as Record<string, unknown>).serverId === 'string' &&
+					typeof (o as Record<string, unknown>).enabled === 'boolean'
+			) as { serverId: string; enabled: boolean }[];
+		} catch {
+			return;
+		}
+
+		const serversRaw = config[SETTINGS_KEYS.MCP_SERVERS];
+		let servers: { id: string; enabled?: boolean }[];
+		try {
+			servers = typeof serversRaw === 'string' ? JSON.parse(serversRaw) : [];
+		} catch {
+			return;
+		}
+
+		if (!Array.isArray(servers)) servers = [];
+
+		let serversChanged = false;
+		const knownIds = new Set(servers.map((s) => s.id));
+		for (const override of overrides) {
+			if (!knownIds.has(override.serverId)) continue;
+			const index = servers.findIndex((s) => s.id === override.serverId);
+
+			if (index >= 0 && servers[index].enabled !== override.enabled) {
+				servers[index] = { ...servers[index], enabled: override.enabled };
+				serversChanged = true;
+			}
+		}
+
+		if (serversChanged) {
+			config[SETTINGS_KEYS.MCP_SERVERS] = JSON.stringify(servers);
+			localStorage.setItem(CONFIG_LOCALSTORAGE_KEY, JSON.stringify(config));
+		}
+
+		if (import.meta.env.DEV && import.meta.env.VITE_DEBUG)
+			console.log(
+				`[Migration] MCP default overrides merge: applied=${overrides.length} serversChanged=${serversChanged} (legacy key preserved)`
+			);
+	}
+};
+
 const migrations: Migration[] = [
 	localStorageMigration,
 	idxdbMigration,
@@ -593,6 +670,7 @@ const migrations: Migration[] = [
 	themeMigration,
 	customJsonKeyMigration,
 	mcpDefaultEnabledMigration,
+	mcpDefaultOverridesMergeMigration,
 	configTypesMigration
 ];
 

tools/ui/src/lib/stores/conversations.svelte.ts

@@ -23,7 +23,8 @@ import { browser } from '$app/environment';
 import { toast } from 'svelte-sonner';
 import { DatabaseService } from '$lib/services/database.service';
 import { MigrationService } from '$lib/services/migration.service';
-import { config, settingsStore } from '$lib/stores/settings.svelte';
+import { config } from '$lib/stores/settings.svelte';
+import { mcpStore } from '$lib/stores/mcp.svelte';
 import { filterByLeafNodeId, findLeafNode, generateConversationTitle } from '$lib/utils';
 import type { McpServerOverride } from '$lib/types/database';
 import { zipSync, unzipSync, strToU8, strFromU8 } from 'fflate';
@@ -46,7 +47,6 @@ import {
 	ISO_TIME_SEPARATOR_REPLACEMENT,
 	NON_ALPHANUMERIC_REGEX,
 	MULTIPLE_UNDERSCORE_REGEX,
-	SETTINGS_KEYS,
 	REASONING_EFFORT_DEFAULT_LOCALSTORAGE_KEY
 } from '$lib/constants';
 
@@ -80,9 +80,6 @@ class ConversationsStore {
 	/** Whether the store has been initialized */
 	isInitialized = $state(false);
 
-	/** Pending MCP server overrides for new conversations (before first message) */
-	pendingMcpServerOverrides = $state<McpServerOverride[]>(ConversationsStore.loadMcpDefaults());
-
 	/** Global (non-conversation-specific) thinking toggle default, derived from reasoning effort */
 	pendingThinkingEnabled = $state(false);
 
@@ -94,28 +91,6 @@ class ConversationsStore {
 	/** Last non-off reasoning effort, restored when re-enabling thinking globally */
 	private lastNonOffEffort: ReasoningEffort | null = null;
 
-	private static loadMcpDefaults(): McpServerOverride[] {
-		const raw = config()[SETTINGS_KEYS.MCP_DEFAULT_SERVER_OVERRIDES];
-		if (typeof raw !== 'string' || raw.length === 0) return [];
-		try {
-			const parsed = JSON.parse(raw);
-			if (!Array.isArray(parsed)) return [];
-			return parsed.filter(
-				(o: unknown) => typeof o === 'object' && o !== null && 'serverId' in o && 'enabled' in o
-			) as McpServerOverride[];
-		} catch {
-			return [];
-		}
-	}
-
-	private saveMcpDefaults(): void {
-		const plain = this.pendingMcpServerOverrides.map((o) => ({
-			serverId: o.serverId,
-			enabled: o.enabled
-		}));
-		settingsStore.updateConfig(SETTINGS_KEYS.MCP_DEFAULT_SERVER_OVERRIDES, JSON.stringify(plain));
-	}
-
 	/** Load reasoning effort default from localStorage */
 	private static loadReasoningEffortDefault(): ReasoningEffort | ReasoningEffort.OFF {
 		if (typeof globalThis.localStorage === 'undefined') return ReasoningEffort.OFF;
@@ -162,11 +137,6 @@ class ConversationsStore {
 
 		try {
 			await MigrationService.runAllMigrations();
-
-			// Re-read defaults after migrations: a migration may have populated
-			// the settings config (e.g. moved legacy MCP overrides into it).
-			this.pendingMcpServerOverrides = ConversationsStore.loadMcpDefaults();
-
 			await this.loadConversations();
 			this.isInitialized = true;
 		} catch (error) {
@@ -273,18 +243,9 @@ class ConversationsStore {
 		const conversationName = name || `Chat ${new Date().toLocaleString()}`;
 		const conversation = await DatabaseService.createConversation(conversationName);
 
-		if (this.pendingMcpServerOverrides.length > 0) {
-			// Deep clone to plain objects (Svelte 5 $state uses Proxies which can't be cloned to IndexedDB)
-			const plainOverrides = this.pendingMcpServerOverrides.map((o) => ({
-				serverId: o.serverId,
-				enabled: o.enabled
-			}));
-			conversation.mcpServerOverrides = plainOverrides;
-			await DatabaseService.updateConversation(conversation.id, {
-				mcpServerOverrides: plainOverrides
-			});
-			this.pendingMcpServerOverrides = [];
-		}
+		// New conversations inherit per-server enabled defaults directly from
+		// `mcpServers[i].enabled` (see #checkServerEnabled). No per-conversation
+		// override list needs to be seeded.
 
 		// Inherit global thinking/reasoning defaults into the new conversation
 		const thinkingEnabled = this.getThinkingEnabled();
@@ -321,7 +282,6 @@ class ConversationsStore {
 				return false;
 			}
 
-			this.pendingMcpServerOverrides = [];
 			this.activeConversation = conversation;
 
 			if (conversation.currNode) {
@@ -351,7 +311,6 @@ class ConversationsStore {
 		this.activeConversation = null;
 		this.activeMessages = [];
 		// reload defaults so new chats inherit persisted state
-		this.pendingMcpServerOverrides = ConversationsStore.loadMcpDefaults();
 		this.pendingReasoningEffort = ConversationsStore.loadReasoningEffortDefault();
 	}
 
@@ -641,11 +600,30 @@ class ConversationsStore {
 	 *
 	 */
 
+	/**
+	/**
+	 * Resolve the per-server enabled value when no active conversation exists.
+	 * The default for new chats is the server's own `enabled` flag in `mcpServers`.
+	 */
+	#getDefaultOverrideForNoConversation(serverId: string): McpServerOverride | undefined {
+		const server = mcpStore.getServers().find((s) => s.id === serverId);
+		if (!server) return undefined;
+		return { serverId, enabled: server.enabled };
+	}
+
+	/**
+	 * Default overrides for new chats are derived from `mcpServers[i].enabled`,
+	 * so the global on/off state lives in one place.
+	 */
+	#getAllDefaultOverridesForNoConversation(): McpServerOverride[] {
+		return mcpStore.getServers().map((s) => ({ serverId: s.id, enabled: s.enabled }));
+	}
+
 	/**
 	 * Gets MCP server override for a specific server in the active conversation.
-	 * Falls back to pending overrides if no active conversation exists.
+	 * Falls back to `mcpServers[i].enabled` if no active conversation exists.
 	 * @param serverId - The server ID to check
-	 * @returns The override if set, undefined if using global setting
+	 * @returns The override if set, undefined if no matching server
 	 */
 	getMcpServerOverride(serverId: string): McpServerOverride | undefined {
 		if (this.activeConversation) {
@@ -653,18 +631,18 @@ class ConversationsStore {
 				(o: McpServerOverride) => o.serverId === serverId
 			);
 		}
-		return this.pendingMcpServerOverrides.find((o) => o.serverId === serverId);
+		return this.#getDefaultOverrideForNoConversation(serverId);
 	}
 
 	/**
 	 * Get all MCP server overrides for the current conversation.
-	 * Returns pending overrides if no active conversation.
+	 * When no active conversation, derives from `mcpServers[i].enabled`.
 	 */
 	getAllMcpServerOverrides(): McpServerOverride[] {
 		if (this.activeConversation?.mcpServerOverrides) {
 			return this.activeConversation.mcpServerOverrides;
 		}
-		return this.pendingMcpServerOverrides;
+		return this.#getAllDefaultOverridesForNoConversation();
 	}
 
 	/**
@@ -679,13 +657,16 @@ class ConversationsStore {
 
 	/**
 	 * Sets or removes MCP server override for the active conversation.
-	 * If no conversation exists, stores as pending override.
+	 * If no conversation exists, persists `enabled` onto `mcpServers[i].enabled`
+	 * (the single source of truth for new-chat defaults).
 	 * @param serverId - The server ID to override
-	 * @param enabled - The enabled state, or undefined to remove override
+	 * @param enabled - The enabled state, or undefined to remove per-conversation override
 	 */
 	async setMcpServerOverride(serverId: string, enabled: boolean | undefined): Promise<void> {
 		if (!this.activeConversation) {
-			this.setPendingMcpServerOverride(serverId, enabled);
+			if (enabled !== undefined) {
+				mcpStore.updateServer(serverId, { enabled });
+			}
 			return;
 		}
 
@@ -729,29 +710,6 @@ class ConversationsStore {
 		}
 	}
 
-	/**
-	 * Sets or removes a pending MCP server override (for new conversations).
-	 */
-	private setPendingMcpServerOverride(serverId: string, enabled: boolean | undefined): void {
-		if (enabled === undefined) {
-			this.pendingMcpServerOverrides = this.pendingMcpServerOverrides.filter(
-				(o) => o.serverId !== serverId
-			);
-		} else {
-			const existingIndex = this.pendingMcpServerOverrides.findIndex(
-				(o) => o.serverId === serverId
-			);
-			if (existingIndex >= 0) {
-				const newOverrides = [...this.pendingMcpServerOverrides];
-				newOverrides[existingIndex] = { serverId, enabled };
-				this.pendingMcpServerOverrides = newOverrides;
-			} else {
-				this.pendingMcpServerOverrides = [...this.pendingMcpServerOverrides, { serverId, enabled }];
-			}
-		}
-		this.saveMcpDefaults();
-	}
-
 	/**
 	 * Toggles MCP server enabled state for the active conversation.
 	 * @param serverId - The server ID to toggle
@@ -769,14 +727,6 @@ class ConversationsStore {
 		await this.setMcpServerOverride(serverId, undefined);
 	}
 
-	/**
-	 * Clears all pending MCP server overrides.
-	 */
-	clearPendingMcpServerOverrides(): void {
-		this.pendingMcpServerOverrides = [];
-		this.saveMcpDefaults();
-	}
-
 	/**
 	 * Gets the effective thinking-enabled state for the active conversation.
 	 * Returns the conversation override if set, otherwise the global default.

tools/ui/src/lib/stores/mcp.svelte.ts

@@ -470,18 +470,12 @@ class MCPStore {
 			}
 		}
 
-		// Fallback: try favicon from root domain
-		const fallbackUrl = this.#getServerFaviconFallback(server.url);
-		if (fallbackUrl) {
-			return fallbackUrl;
-		}
-
-		return null;
+		return this.#getServerFaviconFallback(server.url);
 	}
 
 	/**
 	 * Construct a fallback favicon URL from the MCP server URL.
-	 * e.g. https://mcp.exa.ai/mcp -> https://exa.ai/favicon.ico
+	 * e.g. https://mcp.example.com/sse -> https://example.com/favicon.ico
 	 */
 	#getServerFaviconFallback(serverUrl: string): string | null {
 		try {
@@ -505,27 +499,6 @@ class MCPStore {
 		return null;
 	}
 
-	isAnyServerLoading(): boolean {
-		return this.getServers().some((s) => {
-			const state = this.getHealthCheckState(s.id);
-
-			return (
-				state.status === HealthCheckStatus.IDLE || state.status === HealthCheckStatus.CONNECTING
-			);
-		});
-	}
-
-	getServersSorted(): MCPServerSettingsEntry[] {
-		const servers = this.getServers();
-		if (this.isAnyServerLoading()) {
-			return servers;
-		}
-
-		return [...servers].sort((a, b) =>
-			this.getServerLabel(a).localeCompare(this.getServerLabel(b))
-		);
-	}
-
 	addServer(
 		serverData: Omit<MCPServerSettingsEntry, 'id' | 'requestTimeoutSeconds'> & { id?: string }
 	): MCPServerSettingsEntry {
@@ -579,10 +552,11 @@ class MCPStore {
 	}
 
 	/**
-	 * MCP servers selectable in chat-add UIs and the settings page.
+	 * MCP servers selectable in chat-add UIs and the settings page,
+	 * in the order they were added to the config.
 	 */
 	get visibleMcpServers(): MCPServerSettingsEntry[] {
-		return this.getServersSorted().filter((server) => server.enabled);
+		return this.getServers().filter((server) => server.enabled);
 	}
 
 	async ensureInitialized(perChatOverrides?: McpServerOverride[]): Promise<boolean> {

tools/ui/src/lib/types/index.ts

@@ -128,7 +128,6 @@ export type {
 	MCPClientConfig,
 	MCPServerSettingsEntry,
 	MCPServerDisplayInfo,
-	RecommendedMCPServer,
 	MCPToolCall,
 	OpenAIToolDefinition,
 	ServerStatus,

tools/ui/src/lib/types/mcp.d.ts

@@ -226,15 +226,6 @@ export type MCPServerSettingsEntry = MCPServerDisplayInfo & {
 	useProxy?: boolean;
 };
 
-/**
- * Pre-defined recommended MCP server shown to the user in onboarding/picker UIs.
- */
-export interface RecommendedMCPServer extends MCPServerDisplayInfo {
-	description: string;
-	enabled: boolean;
-	requestTimeoutSeconds: number;
-}
-
 export interface MCPHostManagerConfig {
 	servers: MCPClientConfig['servers'];
 	clientInfo?: Implementation;

tools/ui/src/routes/+layout.svelte

@@ -8,7 +8,6 @@
 	import { onMount } from 'svelte';
 
 	import { SidebarNavigation, DialogConversationTitleUpdate } from '$lib/components/app';
-	import { DialogMcpServerRecommendations } from '$lib/components/app/dialogs';
 	import { PwaMetaTags, PwaRefreshAlert } from '$lib/components/pwa';
 	import { pwaAssetsHead } from 'virtual:pwa-assets/head';
 
@@ -27,7 +26,6 @@
 	import { FAVICON_PATHS, FAVICON_SELECTORS } from '$lib/constants/pwa';
 	import { useKeyboardShortcuts } from '$lib/hooks/use-keyboard-shortcuts.svelte';
 	import { usePwa } from '$lib/hooks/use-pwa.svelte';
-	import { useMcpRecommendations } from '$lib/hooks/use-mcp-recommendations.svelte';
 	import { conversations } from '$lib/stores/conversations.svelte';
 	import { isMobile } from '$lib/stores/viewport.svelte';
 	import { theme } from '$lib/stores/theme.svelte';
@@ -39,8 +37,6 @@
 	let innerHeight = $state<number | undefined>();
 	let innerWidth = $state(browser ? window.innerWidth : 0);
 
-	const mcpRecommendations = useMcpRecommendations();
-
 	let chatSidebar:
 		| {
 				activateSearchMode?: () => void;
@@ -239,7 +235,10 @@
 	});
 
 	// Background MCP server health checks on app load
-	// Fetch enabled servers from settings and run health checks in background
+	// Fetch enabled servers from settings and run health checks in background.
+	// Only IDLE servers are checked; already-resolved (SUCCESS / ERROR) servers
+	// keep their existing state, so adding or removing a server does not flash
+	// every other card back through skeleton state.
 	$effect(() => {
 		if (!browser) return;
 
@@ -251,7 +250,7 @@
 		if (enabledServers.length > 0) {
 			untrack(() => {
 				// Run health checks in background (don't await)
-				mcpStore.runHealthChecksForServers(enabledServers, false).catch((error) => {
+				mcpStore.runHealthChecksForServers(enabledServers, true).catch((error) => {
 					console.warn('[layout] MCP health checks failed:', error);
 				});
 			});
@@ -325,11 +324,6 @@
 		onConfirm={handleTitleUpdateConfirm}
 		onCancel={handleTitleUpdateCancel}
 	/>
-
-	<DialogMcpServerRecommendations
-		open={mcpRecommendations.open}
-		onOpenChange={mcpRecommendations.handleOpenChange}
-	/>
 </Tooltip.Provider>
 
 <!-- PWA update prompt + version -->

tools/ui/tests/unit/mcp-default-overrides-merge.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { STORAGE_APP_NAME, CONFIG_LOCALSTORAGE_KEY } from '$lib/constants';
+
+// node env unit project has no DOM, install a minimal localStorage backed by a Map
+beforeAll(() => {
+	const store = new Map<string, string>();
+	const polyfill: Storage = {
+		get length() {
+			return store.size;
+		},
+		clear: () => store.clear(),
+		getItem: (k) => (store.has(k) ? store.get(k)! : null),
+		key: (i) => Array.from(store.keys())[i] ?? null,
+		removeItem: (k) => {
+			store.delete(k);
+		},
+		setItem: (k, v) => {
+			store.set(k, String(v));
+		}
+	};
+	(globalThis as unknown as { localStorage: Storage }).localStorage = polyfill;
+});
+
+/**
+ * Migration `mcp-default-overrides-merge-v1` folds the values of the parallel
+ * `mcpDefaultServerOverrides` config entry onto `mcpServers[i].enabled` (the
+ * single source of truth for new-chat defaults). The legacy key is kept on
+ * disk for downgrade compatibility.
+ */
+describe('mcp-default-overrides-merge-v1 migration', () => {
+	const MIGRATION_STATE_KEY = `${STORAGE_APP_NAME}.migration-state`;
+	const MCP_DEFAULT_OVERRIDES_KEY = `${STORAGE_APP_NAME}.mcpDefaultServerOverrides`;
+
+	beforeEach(async () => {
+		localStorage.clear();
+		// Reset the migration run counter so `runAllMigrations` is guaranteed to execute.
+		await import('$lib/services/migration.service').then((mod) =>
+			mod.MigrationService.resetState()
+		);
+	});
+
+	afterEach(() => {
+		localStorage.clear();
+	});
+
+	async function runMigrations() {
+		const { MigrationService } = await import('$lib/services/migration.service');
+		await MigrationService.runAllMigrations();
+	}
+
+	function readConfig(): Record<string, unknown> {
+		const raw = localStorage.getItem(CONFIG_LOCALSTORAGE_KEY);
+
+		return raw ? (JSON.parse(raw) as Record<string, unknown>) : {};
+	}
+
+	function writeConfig(config: Record<string, unknown>) {
+		localStorage.setItem(CONFIG_LOCALSTORAGE_KEY, JSON.stringify(config));
+	}
+
+	it('applies matching overrides onto mcpServers[i].enabled and preserves the legacy key', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([
+				{ id: 'exa', enabled: false, url: 'https://mcp.exa.ai/mcp' },
+				{ id: 'hf', enabled: false, url: 'https://huggingface.co/mcp' }
+			]),
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([
+				{ serverId: 'exa', enabled: true },
+				{ serverId: 'hf', enabled: false }
+			])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		const servers = JSON.parse(after.mcpServers as string) as Array<{
+			id: string;
+			enabled: boolean;
+		}>;
+
+		expect(servers.find((s) => s.id === 'exa')?.enabled).toBe(true);
+		expect(servers.find((s) => s.id === 'hf')?.enabled).toBe(false);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(true);
+	});
+
+	it('skips override ids that do not match any configured server', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([{ id: 'exa', enabled: false, url: 'https://mcp.exa.ai/mcp' }]),
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([
+				{ serverId: 'orphan', enabled: true },
+				{ serverId: 'exa', enabled: true }
+			])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		const servers = JSON.parse(after.mcpServers as string) as Array<{
+			id: string;
+			enabled: boolean;
+		}>;
+
+		expect(servers).toHaveLength(1);
+		expect(servers[0].enabled).toBe(true);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(true);
+	});
+
+	it('is a no-op when there are no legacy overrides', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([{ id: 'exa', enabled: true, url: 'https://mcp.exa.ai/mcp' }])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		const servers = JSON.parse(after.mcpServers as string) as Array<{
+			id: string;
+			enabled: boolean;
+		}>;
+
+		expect(servers[0].enabled).toBe(true);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(false);
+	});
+
+	it('does not rewrite mcpServers when override.enabled already matches', async () => {
+		const originalServers = JSON.stringify([
+			{ id: 'exa', enabled: true, url: 'https://mcp.exa.ai/mcp' }
+		]);
+
+		writeConfig({
+			mcpServers: originalServers,
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([{ serverId: 'exa', enabled: true }])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		expect(after.mcpServers).toBe(originalServers);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(true);
+	});
+
+	it('records itself as completed so subsequent loads do not re-run', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([{ id: 'exa', enabled: false, url: 'https://mcp.exa.ai/mcp' }]),
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([{ serverId: 'exa', enabled: true }])
+		});
+
+		const { MigrationService } = await import('$lib/services/migration.service');
+
+		await MigrationService.runAllMigrations();
+
+		const stateRaw = localStorage.getItem(MIGRATION_STATE_KEY);
+		expect(stateRaw).not.toBeNull();
+		const state = JSON.parse(stateRaw!) as { completed: string[]; failed: string[] };
+		expect(state.completed).toContain('mcp-default-overrides-merge-v1');
+		expect(state.failed).not.toContain('mcp-default-overrides-merge-v1');
+	});
+});

tools/ui/tests/unit/mcp-servers-default.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { SETTINGS_KEYS } from '$lib/constants/settings-keys';
+
+/**
+ * Default-value policy for the `MCP_SERVERS` setting.
+ *
+ * Earlier versions of the UI preloaded a hard-coded list of suggested
+ * MCP servers into this setting on first install. That caused silent
+ * third-party HTTP requests at app load (see issue #25509) and a popup
+ * "recommendation" dialog (see issue #25274). New users must now opt
+ * in explicitly when adding a server, so the default is an empty list.
+ */
+describe('MCP_SERVERS default value', () => {
+	it('does not preload any servers in the MCP_SERVERS setting default', async () => {
+		const { SETTING_CONFIG_DEFAULT } = await import('$lib/constants/settings-registry');
+
+		expect(SETTING_CONFIG_DEFAULT[SETTINGS_KEYS.MCP_SERVERS]).toBe('[]');
+	}, 15000);
+});

tools/ui/tests/unit/parse-mcp-server-settings.test.ts

@@ -5,11 +5,10 @@ import { DEFAULT_MCP_CONFIG, MCP_SERVER_ID_PREFIX } from '$lib/constants/mcp';
 /**
  * Tests for the mcpServers settings parser.
  *
- * The branch seeds the MCP servers setting with a default value of
- * `JSON.stringify(RECOMMENDED_MCP_SERVERS)`, so the parser has to be
- * resilient to anything that may live in the user's localStorage: malformed
- * JSON, wrong shapes, missing fields, falsy-but-not-zero numbers, and entry
- * arrays that have been mutated by the user via the settings form.
+ * The parser has to be resilient to anything that may live in the
+ * user's localStorage: malformed JSON, wrong shapes, missing fields,
+ * falsy-but-not-zero numbers, and entry arrays that have been mutated
+ * by the user via the settings form.
  */
 describe('parseMcpServerSettings', () => {
 	it('returns an empty array for falsy or whitespace-only input', () => {

tools/ui/tests/unit/recommended-mcp-servers.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	RECOMMENDED_MCP_SERVER_IDS,
-	RECOMMENDED_MCP_SERVERS
-} from '$lib/constants/recommended-mcp-servers';
-import { parseMcpServerSettings } from '$lib/utils/mcp';
-import { DEFAULT_MCP_CONFIG, MCP_SERVER_ID_PREFIX } from '$lib/constants/mcp';
-
-/**
- * Tests for the predefined recommended MCP servers.
- *
- * These are surfaced to first-time users via
- * DialogMcpServerRecommendations and used as the default value of the MCP
- * servers setting, so a regression that breaks the round-trip through the
- * settings parser would silently break onboarding for new users.
- */
-describe('RECOMMENDED_MCP_SERVERS', () => {
-	it('lists at least one entry and uses stable, unique ids', () => {
-		expect(RECOMMENDED_MCP_SERVERS.length).toBeGreaterThan(0);
-
-		const ids = RECOMMENDED_MCP_SERVERS.map((server) => server.id);
-		expect(new Set(ids).size).toBe(ids.length);
-
-		for (const id of ids) {
-			expect(id).toMatch(/^[a-z0-9-]+$/);
-			expect(id.toLowerCase()).not.toContain(MCP_SERVER_ID_PREFIX.toLowerCase());
-		}
-	});
-
-	it('requires a name, description and url for every entry', () => {
-		for (const server of RECOMMENDED_MCP_SERVERS) {
-			expect(server.name?.trim().length ?? 0).toBeGreaterThan(0);
-			expect(server.description.trim().length).toBeGreaterThan(0);
-			expect(server.url.trim().length).toBeGreaterThan(0);
-			expect(() => new URL(server.url)).not.toThrow();
-		}
-	});
-});
-
-describe('RECOMMENDED_MCP_SERVER_IDS', () => {
-	it('matches the ids declared in RECOMMENDED_MCP_SERVERS', () => {
-		expect(RECOMMENDED_MCP_SERVER_IDS.size).toBe(RECOMMENDED_MCP_SERVERS.length);
-
-		for (const server of RECOMMENDED_MCP_SERVERS) {
-			expect(RECOMMENDED_MCP_SERVER_IDS.has(server.id)).toBe(true);
-		}
-	});
-});
-
-describe('recommended-mcp-servers default value', () => {
-	it('round-trips cleanly through parseMcpServerSettings', () => {
-		const serialized = JSON.stringify(RECOMMENDED_MCP_SERVERS);
-		const parsed = parseMcpServerSettings(serialized);
-
-		expect(parsed).toHaveLength(RECOMMENDED_MCP_SERVERS.length);
-
-		for (let index = 0; index < RECOMMENDED_MCP_SERVERS.length; index++) {
-			const source = RECOMMENDED_MCP_SERVERS[index];
-			const entry = parsed[index];
-
-			expect(entry).toBeDefined();
-			expect(entry?.id).toBe(source.id);
-			expect(entry?.url).toBe(source.url);
-			expect(entry?.enabled).toBe(source.enabled);
-			expect(entry?.requestTimeoutSeconds).toBe(source.requestTimeoutSeconds);
-			expect(entry?.name).toBe(source.name);
-
-			// Headers and useProxy are not set on recommended servers; the
-			// parser must fall back to the inactive defaults rather than
-			// surfacing undefined-boundary states.
-			expect(entry?.headers).toBeUndefined();
-			expect(entry?.useProxy).toBe(false);
-		}
-	});
-
-	it('uses the global default timeout when one is not specified on an entry', () => {
-		const sourceOnlyRequired = {
-			id: 'roundtrip-only',
-			name: 'Only required fields',
-			url: 'https://example.test/mcp',
-			description: 'Smoke entry for parser roundtrip with default timeout.',
-			enabled: true
-		};
-
-		const parsed = parseMcpServerSettings(JSON.stringify([sourceOnlyRequired]));
-		const entry = parsed[0];
-
-		expect(entry?.requestTimeoutSeconds).toBe(DEFAULT_MCP_CONFIG.requestTimeoutSeconds);
-	});
-});