Enhancement: Disable markdown formatting in Thinking/Reasoning UI

[insilications]

What features would you like to see added?

It would be nice to be able to disable markdown formatting in the Thinking UI.

More details

The Reasoning UI is working great (7818ae5), but the very nature of the LLM thinking sometimes generates broken markdown formatting.

Which components are impacted by your request?

No response

Pictures

No response

Code of Conduct

• I agree to follow this project's Code of Conduct

[berry-13]

Can you show some examples? The thinking UI is based on the Markdown component, so you can't just disable it. But if there are serious issues, we could add an option to disable it and show only plain text

[insilications]

An example:

<think>
But step 2 can also be optimized with SIMD. For example, after finding a candidate position i, compare the next m-1 bytes in the haystack starting at i+1 with the pattern's next m-1 bytes using SIMD chunks.

This way, even the verification step can be vectorized.

Putting this together, the function would look something like:

size_t findSubstringSIMD(const char* pattern, size_t patternLen, const char* path, size_t pathLen) {
    if (patternLen == 0) return 0;
    if (pathLen < patternLen) return max_size;
    const size_t lastPossible = pathLen - patternLen;

    const char firstChar = pattern[0];
    for (size_t i = 0; i <= lastPossible; ) {
        // Find the next occurrence of firstChar in path starting at i
        // Using SIMD to scan for firstChar in chunks
        // Once found, check the rest of the pattern
        size_t next = simd_scan_first_char(path + i, lastPossible - i + 1, firstChar);
        if (next == max_size) break;
        i += next;
        if (i + patternLen > pathLen) break;
        bool match = true;
        // Check the remaining characters
        for (size_t j = 1; j < patternLen; ) {
            // Use SIMD to compare chunks
            size_t chunkSize = SIMD_CHUNK_SIZE;
            if (j + chunkSize > patternLen) chunkSize = patternLen - j;
            __m128i patternChunk = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pattern + j));
            __m128i pathChunk = _mm_loadu_si128(reinterpret_cast<const __m128i*>(path + i + j));
            __m128i cmp = _mm_cmpeq_epi8(patternChunk, pathChunk);
            if (_mm_movemask_epi8(cmp) != 0xFFFF) {
                match = false;
                break;
            }
            j += chunkSize;
        }
        if (match) return i;
        i++;
    }
    return max_size;
}

But this is a rough sketch. The key part is the SIMD scan for the first character, then verifying the rest with SIMD.

But how to implement the simd_scan_first_char function using SIMD?

For example, using SSE2:

size_t simd_scan_first_char(const char* s, size_t len, char first) {
    const __m128i firstVec = _mm_set1_epi8(first);
    size_t i = 0;
    for (; i + 16 <= len; i += 16) {
        __m128i chunk = _mm_loadu_si128(reinterpret_cast<const __m128i*>(s + i));
        __m128i cmp = _mm_cmpeq_epi8(chunk, firstVec);
        int mask = _mm_movemask_epi8(cmp);
        if (mask != 0) {
            // Find the position of the first set bit in mask
            return i + __builtin_ctz(mask);
        }
    }
    // Handle remaining bytes
    for (; i < len; ++i) {
        if (s[i] == first) {
            return i;
        }
    }
    return max_size;
}
</think>