feat(qwen-tts): add Qwen-tts backend (#8163)

* feat(qwen-tts): add Qwen-tts backend

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

* Update intel deps

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

* Drop flash-attn for cuda13

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

---------

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

.github/workflows/backend.yml

@@ -105,6 +105,19 @@ jobs:
             dockerfile: "./backend/Dockerfile.python"
             context: "./"
             ubuntu-version: '2404'
+          - build-type: 'cublas'
+            cuda-major-version: "12"
+            cuda-minor-version: "9"
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-nvidia-cuda-12-qwen-tts'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:24.04"
+            skip-drivers: 'false'
+            backend: "qwen-tts"
+            dockerfile: "./backend/Dockerfile.python"
+            context: "./"
+            ubuntu-version: '2404'
           - build-type: 'cublas'
             cuda-major-version: "12"
             cuda-minor-version: "9"
@@ -353,6 +366,19 @@ jobs:
             dockerfile: "./backend/Dockerfile.python"
             context: "./"
             ubuntu-version: '2404'
+          - build-type: 'cublas'
+            cuda-major-version: "13"
+            cuda-minor-version: "0"
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-nvidia-cuda-13-qwen-tts'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:24.04"
+            skip-drivers: 'false'
+            backend: "qwen-tts"
+            dockerfile: "./backend/Dockerfile.python"
+            context: "./"
+            ubuntu-version: '2404'
           - build-type: 'cublas'
             cuda-major-version: "13"
             cuda-minor-version: "0"
@@ -431,6 +457,19 @@ jobs:
             backend: "vibevoice"
             dockerfile: "./backend/Dockerfile.python"
             context: "./"
+          - build-type: 'l4t'
+            cuda-major-version: "13"
+            cuda-minor-version: "0"
+            platforms: 'linux/arm64'
+            tag-latest: 'auto'
+            tag-suffix: '-nvidia-l4t-cuda-13-arm64-qwen-tts'
+            runs-on: 'ubuntu-24.04-arm'
+            base-image: "ubuntu:24.04"
+            skip-drivers: 'false'
+            ubuntu-version: '2404'
+            backend: "qwen-tts"
+            dockerfile: "./backend/Dockerfile.python"
+            context: "./"
           - build-type: 'l4t'
             cuda-major-version: "13"
             cuda-minor-version: "0"
@@ -680,6 +719,19 @@ jobs:
             dockerfile: "./backend/Dockerfile.python"
             context: "./"
             ubuntu-version: '2404'
+          - build-type: 'hipblas'
+            cuda-major-version: ""
+            cuda-minor-version: ""
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-rocm-hipblas-qwen-tts'
+            runs-on: 'arc-runner-set'
+            base-image: "rocm/dev-ubuntu-24.04:6.4.4"
+            skip-drivers: 'false'
+            backend: "qwen-tts"
+            dockerfile: "./backend/Dockerfile.python"
+            context: "./"
+            ubuntu-version: '2404'
           - build-type: 'hipblas'
             cuda-major-version: ""
             cuda-minor-version: ""
@@ -824,6 +876,19 @@ jobs:
             dockerfile: "./backend/Dockerfile.python"
             context: "./"
             ubuntu-version: '2204'
+          - build-type: 'l4t'
+            cuda-major-version: "12"
+            cuda-minor-version: "0"
+            platforms: 'linux/arm64'
+            tag-latest: 'auto'
+            tag-suffix: '-nvidia-l4t-qwen-tts'
+            runs-on: 'ubuntu-24.04-arm'
+            base-image: "nvcr.io/nvidia/l4t-jetpack:r36.4.0"
+            skip-drivers: 'true'
+            backend: "qwen-tts"
+            dockerfile: "./backend/Dockerfile.python"
+            context: "./"
+            ubuntu-version: '2204'
           - build-type: 'l4t'
             cuda-major-version: "12"
             cuda-minor-version: "0"
@@ -890,6 +955,19 @@ jobs:
             dockerfile: "./backend/Dockerfile.python"
             context: "./"
             ubuntu-version: '2404'
+          - build-type: 'intel'
+            cuda-major-version: ""
+            cuda-minor-version: ""
+            platforms: 'linux/amd64'
+            tag-latest: 'auto'
+            tag-suffix: '-gpu-intel-qwen-tts'
+            runs-on: 'arc-runner-set'
+            base-image: "intel/oneapi-basekit:2025.3.0-0-devel-ubuntu24.04"
+            skip-drivers: 'false'
+            backend: "qwen-tts"
+            dockerfile: "./backend/Dockerfile.python"
+            context: "./"
+            ubuntu-version: '2404'
           - build-type: 'intel'
             cuda-major-version: ""
             cuda-minor-version: ""
@@ -1343,6 +1421,19 @@ jobs:
             dockerfile: "./backend/Dockerfile.python"
             context: "./"
             ubuntu-version: '2404'
+          - build-type: ''
+            cuda-major-version: ""
+            cuda-minor-version: ""
+            platforms: 'linux/amd64,linux/arm64'
+            tag-latest: 'auto'
+            tag-suffix: '-cpu-qwen-tts'
+            runs-on: 'ubuntu-latest'
+            base-image: "ubuntu:24.04"
+            skip-drivers: 'false'
+            backend: "qwen-tts"
+            dockerfile: "./backend/Dockerfile.python"
+            context: "./"
+            ubuntu-version: '2404'
           - build-type: ''
             cuda-major-version: ""
             cuda-minor-version: ""

.github/workflows/test-extra.yml

@@ -284,4 +284,23 @@ jobs:
       - name: Test pocket-tts
         run: |
           make --jobs=5 --output-sync=target -C backend/python/pocket-tts
-          make --jobs=5 --output-sync=target -C backend/python/pocket-tts test
+          make --jobs=5 --output-sync=target -C backend/python/pocket-tts test
+  tests-qwen-tts:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone
+        uses: actions/checkout@v6
+        with:
+          submodules: true
+      - name: Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install build-essential ffmpeg
+          sudo apt-get install -y ca-certificates cmake curl patch python3-pip
+          # Install UV
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          pip install --user --no-cache-dir grpcio-tools==1.64.1
+      - name: Test qwen-tts
+        run: |
+          make --jobs=5 --output-sync=target -C backend/python/qwen-tts
+          make --jobs=5 --output-sync=target -C backend/python/qwen-tts test

Dockerfile

@@ -10,7 +10,7 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
         ca-certificates curl wget espeak-ng libgomp1 \
-        ffmpeg libopenblas0 libopenblas-dev && \
+        ffmpeg libopenblas0 libopenblas-dev sox && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 

Makefile

@@ -1,5 +1,5 @@
 # Disable parallel execution for backend builds
-.NOTPARALLEL: backends/diffusers backends/llama-cpp backends/piper backends/stablediffusion-ggml backends/whisper backends/faster-whisper backends/silero-vad backends/local-store backends/huggingface backends/rfdetr backends/kitten-tts backends/kokoro backends/chatterbox backends/llama-cpp-darwin backends/neutts build-darwin-python-backend build-darwin-go-backend backends/mlx backends/diffuser-darwin backends/mlx-vlm backends/mlx-audio backends/stablediffusion-ggml-darwin backends/vllm backends/moonshine backends/pocket-tts
+.NOTPARALLEL: backends/diffusers backends/llama-cpp backends/piper backends/stablediffusion-ggml backends/whisper backends/faster-whisper backends/silero-vad backends/local-store backends/huggingface backends/rfdetr backends/kitten-tts backends/kokoro backends/chatterbox backends/llama-cpp-darwin backends/neutts build-darwin-python-backend build-darwin-go-backend backends/mlx backends/diffuser-darwin backends/mlx-vlm backends/mlx-audio backends/stablediffusion-ggml-darwin backends/vllm backends/moonshine backends/pocket-tts backends/qwen-tts
 
 GOCMD=go
 GOTEST=$(GOCMD) test
@@ -317,6 +317,7 @@ prepare-test-extra: protogen-python
 	$(MAKE) -C backend/python/vibevoice
 	$(MAKE) -C backend/python/moonshine
 	$(MAKE) -C backend/python/pocket-tts
+	$(MAKE) -C backend/python/qwen-tts
 
 test-extra: prepare-test-extra
 	$(MAKE) -C backend/python/transformers test
@@ -326,6 +327,7 @@ test-extra: prepare-test-extra
 	$(MAKE) -C backend/python/vibevoice test
 	$(MAKE) -C backend/python/moonshine test
 	$(MAKE) -C backend/python/pocket-tts test
+	$(MAKE) -C backend/python/qwen-tts test
 
 DOCKER_IMAGE?=local-ai
 DOCKER_AIO_IMAGE?=local-ai-aio
@@ -459,6 +461,7 @@ BACKEND_CHATTERBOX = chatterbox|python|.|false|true
 BACKEND_VIBEVOICE = vibevoice|python|.|--progress=plain|true
 BACKEND_MOONSHINE = moonshine|python|.|false|true
 BACKEND_POCKET_TTS = pocket-tts|python|.|false|true
+BACKEND_QWEN_TTS = qwen-tts|python|.|false|true
 
 # Helper function to build docker image for a backend
 # Usage: $(call docker-build-backend,BACKEND_NAME,DOCKERFILE_TYPE,BUILD_CONTEXT,PROGRESS_FLAG,NEEDS_BACKEND_ARG)
@@ -505,12 +508,13 @@ $(eval $(call generate-docker-build-target,$(BACKEND_CHATTERBOX)))
 $(eval $(call generate-docker-build-target,$(BACKEND_VIBEVOICE)))
 $(eval $(call generate-docker-build-target,$(BACKEND_MOONSHINE)))
 $(eval $(call generate-docker-build-target,$(BACKEND_POCKET_TTS)))
+$(eval $(call generate-docker-build-target,$(BACKEND_QWEN_TTS)))
 
 # Pattern rule for docker-save targets
 docker-save-%: backend-images
 	docker save local-ai-backend:$* -o backend-images/$*.tar
 
-docker-build-backends: docker-build-llama-cpp docker-build-rerankers docker-build-vllm docker-build-transformers docker-build-diffusers docker-build-kokoro docker-build-faster-whisper docker-build-coqui docker-build-bark docker-build-chatterbox docker-build-vibevoice docker-build-exllama2 docker-build-moonshine docker-build-pocket-tts
+docker-build-backends: docker-build-llama-cpp docker-build-rerankers docker-build-vllm docker-build-transformers docker-build-diffusers docker-build-kokoro docker-build-faster-whisper docker-build-coqui docker-build-bark docker-build-chatterbox docker-build-vibevoice docker-build-exllama2 docker-build-moonshine docker-build-pocket-tts docker-build-qwen-tts
 
 ########################################################
 ### END Backends

README.md

@@ -298,6 +298,7 @@ LocalAI supports a comprehensive range of AI backends with multiple acceleration
 | **neutts** | Text-to-speech with voice cloning | CUDA 12/13, ROCm, CPU |
 | **vibevoice** | Real-time TTS with voice cloning | CUDA 12/13, ROCm, Intel, CPU |
 | **pocket-tts** | Lightweight CPU-based TTS | CUDA 12/13, ROCm, Intel, CPU |
+| **qwen-tts** | High-quality TTS with custom voice, voice design, and voice cloning | CUDA 12/13, ROCm, Intel, CPU |
 
 ### Image & Video Generation
 | Backend | Description | Acceleration Support |
@@ -319,8 +320,8 @@ LocalAI supports a comprehensive range of AI backends with multiple acceleration
 |-------------------|-------------------|------------------|
 | **NVIDIA CUDA 12** | All CUDA-compatible backends | Nvidia hardware |
 | **NVIDIA CUDA 13** | All CUDA-compatible backends | Nvidia hardware |
-| **AMD ROCm** | llama.cpp, whisper, vllm, transformers, diffusers, rerankers, coqui, kokoro, bark, neutts, vibevoice, pocket-tts | AMD Graphics |
-| **Intel oneAPI** | llama.cpp, whisper, stablediffusion, vllm, transformers, diffusers, rfdetr, rerankers, exllama2, coqui, kokoro, bark, vibevoice, pocket-tts | Intel Arc, Intel iGPUs |
+| **AMD ROCm** | llama.cpp, whisper, vllm, transformers, diffusers, rerankers, coqui, kokoro, bark, neutts, vibevoice, pocket-tts, qwen-tts | AMD Graphics |
+| **Intel oneAPI** | llama.cpp, whisper, stablediffusion, vllm, transformers, diffusers, rfdetr, rerankers, exllama2, coqui, kokoro, bark, vibevoice, pocket-tts, qwen-tts | Intel Arc, Intel iGPUs |
 | **Apple Metal** | llama.cpp, whisper, diffusers, MLX, MLX-VLM, bark-cpp | Apple M1/M2/M3+ |
 | **Vulkan** | llama.cpp, whisper, stablediffusion | Cross-platform GPUs |
 | **NVIDIA Jetson (CUDA 12)** | llama.cpp, whisper, stablediffusion, diffusers, rfdetr | ARM64 embedded AI (AGX Orin, etc.) |

backend/backend.proto

@@ -32,6 +32,8 @@ service Backend {
   rpc GetMetrics(MetricsRequest) returns (MetricsResponse);
 
   rpc VAD(VADRequest) returns (VADResponse) {}
+
+  rpc ModelMetadata(ModelOptions) returns (ModelMetadataResponse) {}
 }
 
 // Define the empty request
@@ -410,3 +412,8 @@ message Detection {
 message DetectResponse {
   repeated Detection Detections = 1;
 }
+
+message ModelMetadataResponse {
+  bool supports_thinking = 1;
+  string rendered_template = 2;  // The rendered chat template with enable_thinking=true (empty if not applicable)
+}

backend/cpp/llama-cpp/Makefile

@@ -1,5 +1,5 @@
 
-LLAMA_VERSION?=959ecf7f234dc0bc0cd6829b25cb0ee1481aa78a
+LLAMA_VERSION?=a5eaa1d6a3732bc0f460b02b61c95680bba5a012
 LLAMA_REPO?=https://github.com/ggerganov/llama.cpp
 
 CMAKE_ARGS?=

backend/cpp/llama-cpp/grpc-server.cpp

@@ -83,8 +83,8 @@ static void start_llama_server(server_context& ctx_server) {
 
     // print sample chat example to make it clear which template is used
     // LOG_INF("%s: chat template, chat_template: %s, example_format: '%s'\n", __func__,
-    //     common_chat_templates_source(ctx_server.impl->chat_templates.get()),
-    //     common_chat_format_example(ctx_server.impl->chat_templates.get(), ctx_server.impl->params_base.use_jinja).c_str(), ctx_server.impl->params_base.default_template_kwargs);
+    //     common_chat_templates_source(ctx_server.impl->chat_params.tmpls.get()),
+    //     common_chat_format_example(ctx_server.impl->chat_params.tmpls.get(), ctx_server.impl->params_base.use_jinja).c_str(), ctx_server.impl->params_base.default_template_kwargs);
 
     // Keep the chat templates initialized in load_model() so they can be used when UseTokenizerTemplate is enabled
     // Templates will only be used conditionally in Predict/PredictStream when UseTokenizerTemplate is true and Messages are provided
@@ -882,7 +882,7 @@ public:
             std::string prompt_str;
             std::vector<raw_buffer> files; // Declare files early so it's accessible in both branches
             // Handle chat templates when UseTokenizerTemplate is enabled and Messages are provided
-            if (request->usetokenizertemplate() && request->messages_size() > 0 && ctx_server.impl->chat_templates != nullptr) {
+            if (request->usetokenizertemplate() && request->messages_size() > 0 && ctx_server.impl->chat_params.tmpls != nullptr) {
                 // Convert proto Messages to JSON format compatible with oaicompat_chat_params_parse
                 json body_json;
                 json messages_json = json::array();
@@ -1261,12 +1261,7 @@ public:
                 // Use the same approach as server.cpp: call oaicompat_chat_params_parse
                 // This handles all template application, grammar merging, etc. automatically
                 // Files extracted from multimodal content in messages will be added to the files vector
-                // Create parser options with current chat_templates to ensure tmpls is not null
-                oaicompat_parser_options parser_opt = ctx_server.impl->oai_parser_opt;
-                parser_opt.tmpls = ctx_server.impl->chat_templates.get(); // Ensure tmpls is set to current chat_templates
-                // Update allow_image and allow_audio based on current mctx state
-                parser_opt.allow_image = ctx_server.impl->mctx ? mtmd_support_vision(ctx_server.impl->mctx) : false;
-                parser_opt.allow_audio = ctx_server.impl->mctx ? mtmd_support_audio(ctx_server.impl->mctx) : false;
+                // chat_params already contains tmpls, allow_image, and allow_audio set during model loading
 
                 // Debug: Log tools before template processing
                 if (body_json.contains("tools")) {
@@ -1312,7 +1307,7 @@ public:
                     }
                 }
 
-                json parsed_data = oaicompat_chat_params_parse(body_json, parser_opt, files);
+                json parsed_data = oaicompat_chat_params_parse(body_json, ctx_server.impl->chat_params, files);
 
                 // Debug: Log tools after template processing
                 if (parsed_data.contains("tools")) {
@@ -1365,7 +1360,7 @@ public:
 
             // If not using chat templates, extract files from image_data/audio_data fields
             // (If using chat templates, files were already extracted by oaicompat_chat_params_parse)
-            if (!request->usetokenizertemplate() || request->messages_size() == 0 || ctx_server.impl->chat_templates == nullptr) {
+            if (!request->usetokenizertemplate() || request->messages_size() == 0 || ctx_server.impl->chat_params.tmpls == nullptr) {
                 const auto &images_data = data.find("image_data");
                 if (images_data != data.end() && images_data->is_array())
                 {
@@ -1593,7 +1588,7 @@ public:
             std::string prompt_str;
             std::vector<raw_buffer> files; // Declare files early so it's accessible in both branches
             // Handle chat templates when UseTokenizerTemplate is enabled and Messages are provided
-            if (request->usetokenizertemplate() && request->messages_size() > 0 && ctx_server.impl->chat_templates != nullptr) {
+            if (request->usetokenizertemplate() && request->messages_size() > 0 && ctx_server.impl->chat_params.tmpls != nullptr) {
                 // Convert proto Messages to JSON format compatible with oaicompat_chat_params_parse
                 json body_json;
                 json messages_json = json::array();
@@ -1997,12 +1992,7 @@ public:
                 // Use the same approach as server.cpp: call oaicompat_chat_params_parse
                 // This handles all template application, grammar merging, etc. automatically
                 // Files extracted from multimodal content in messages will be added to the files vector
-                // Create parser options with current chat_templates to ensure tmpls is not null
-                oaicompat_parser_options parser_opt = ctx_server.impl->oai_parser_opt;
-                parser_opt.tmpls = ctx_server.impl->chat_templates.get(); // Ensure tmpls is set to current chat_templates
-                // Update allow_image and allow_audio based on current mctx state
-                parser_opt.allow_image = ctx_server.impl->mctx ? mtmd_support_vision(ctx_server.impl->mctx) : false;
-                parser_opt.allow_audio = ctx_server.impl->mctx ? mtmd_support_audio(ctx_server.impl->mctx) : false;
+                // chat_params already contains tmpls, allow_image, and allow_audio set during model loading
 
                 // Debug: Log tools before template processing
                 if (body_json.contains("tools")) {
@@ -2048,7 +2038,7 @@ public:
                     }
                 }
 
-                json parsed_data = oaicompat_chat_params_parse(body_json, parser_opt, files);
+                json parsed_data = oaicompat_chat_params_parse(body_json, ctx_server.impl->chat_params, files);
 
                 // Debug: Log tools after template processing
                 if (parsed_data.contains("tools")) {
@@ -2101,7 +2091,7 @@ public:
 
             // If not using chat templates, extract files from image_data/audio_data fields
             // (If using chat templates, files were already extracted by oaicompat_chat_params_parse)
-            if (!request->usetokenizertemplate() || request->messages_size() == 0 || ctx_server.impl->chat_templates == nullptr) {
+            if (!request->usetokenizertemplate() || request->messages_size() == 0 || ctx_server.impl->chat_params.tmpls == nullptr) {
                 const auto &images_data = data.find("image_data");
                 if (images_data != data.end() && images_data->is_array())
                 {
@@ -2486,6 +2476,47 @@ public:
         response->set_prompt_tokens_processed(res_metrics->n_prompt_tokens_processed_total);
 
 
+        return grpc::Status::OK;
+    }
+
+    grpc::Status ModelMetadata(ServerContext* /*context*/, const backend::ModelOptions* /*request*/, backend::ModelMetadataResponse* response) override {
+        // Check if model is loaded
+        if (params_base.model.path.empty()) {
+            return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "Model not loaded");
+        }
+
+        // Check if chat templates are initialized
+        if (ctx_server.impl->chat_params.tmpls == nullptr) {
+            // If templates are not initialized, we can't detect thinking support
+            // Return false as default
+            response->set_supports_thinking(false);
+            response->set_rendered_template("");
+            return grpc::Status::OK;
+        }
+
+        // Detect thinking support using llama.cpp's function
+        bool supports_thinking = common_chat_templates_support_enable_thinking(ctx_server.impl->chat_params.tmpls.get());
+        response->set_supports_thinking(supports_thinking);
+
+        // Render the template with enable_thinking=true so Go code can detect thinking tokens
+        // This allows reusing existing detection functions in Go
+        std::string rendered_template = "";
+        if (params_base.use_jinja) {
+            // Render the template with enable_thinking=true to see what the actual prompt looks like
+            common_chat_templates_inputs dummy_inputs;
+            common_chat_msg msg;
+            msg.role = "user";
+            msg.content = "test";
+            dummy_inputs.messages = {msg};
+            dummy_inputs.enable_thinking = true;
+            dummy_inputs.use_jinja = params_base.use_jinja;
+            
+            const auto rendered = common_chat_templates_apply(ctx_server.impl->chat_params.tmpls.get(), dummy_inputs);
+            rendered_template = rendered.prompt;
+        }
+        
+        response->set_rendered_template(rendered_template);
+
         return grpc::Status::OK;
     }
 };

backend/go/stablediffusion-ggml/Makefile

@@ -8,7 +8,7 @@ JOBS?=$(shell nproc --ignore=1)
 
 # stablediffusion.cpp (ggml)
 STABLEDIFFUSION_GGML_REPO?=https://github.com/leejet/stable-diffusion.cpp
-STABLEDIFFUSION_GGML_VERSION?=a48b4a3ade9972faf0adcad47e51c6fc03f0e46d
+STABLEDIFFUSION_GGML_VERSION?=5e4579c11d0678f9765463582d024e58270faa9c
 
 CMAKE_ARGS+=-DGGML_MAX_NAME=128
 

backend/go/whisper/Makefile

@@ -8,7 +8,7 @@ JOBS?=$(shell nproc --ignore=1)
 
 # whisper.cpp version
 WHISPER_REPO?=https://github.com/ggml-org/whisper.cpp
-WHISPER_CPP_VERSION?=f53dc74843e97f19f94a79241357f74ad5b691a6
+WHISPER_CPP_VERSION?=7aa8818647303b567c3a21fe4220b2681988e220
 SO_TARGET?=libgowhisper.so
 
 CMAKE_ARGS+=-DBUILD_SHARED_LIBS=OFF

backend/index.yaml

@@ -428,6 +428,28 @@
     nvidia-l4t-cuda-12: "nvidia-l4t-vibevoice"
     nvidia-l4t-cuda-13: "cuda13-nvidia-l4t-arm64-vibevoice"
   icon: https://avatars.githubusercontent.com/u/6154722?s=200&v=4
+- &qwen-tts
+  urls:
+    - https://github.com/QwenLM/Qwen3-TTS
+  description: |
+    Qwen3-TTS is a high-quality text-to-speech model supporting custom voice, voice design, and voice cloning.
+  tags:
+    - text-to-speech
+    - TTS
+  license: apache-2.0
+  name: "qwen-tts"
+  alias: "qwen-tts"
+  capabilities:
+    nvidia: "cuda12-qwen-tts"
+    intel: "intel-qwen-tts"
+    amd: "rocm-qwen-tts"
+    nvidia-l4t: "nvidia-l4t-qwen-tts"
+    default: "cpu-qwen-tts"
+    nvidia-cuda-13: "cuda13-qwen-tts"
+    nvidia-cuda-12: "cuda12-qwen-tts"
+    nvidia-l4t-cuda-12: "nvidia-l4t-qwen-tts"
+    nvidia-l4t-cuda-13: "cuda13-nvidia-l4t-arm64-qwen-tts"
+  icon: https://avatars.githubusercontent.com/u/6154722?s=200&v=4
 - &pocket-tts
   urls:
     - https://github.com/kyutai-labs/pocket-tts
@@ -1613,6 +1635,89 @@
   uri: "quay.io/go-skynet/local-ai-backends:master-nvidia-l4t-cuda-13-arm64-vibevoice"
   mirrors:
     - localai/localai-backends:master-nvidia-l4t-cuda-13-arm64-vibevoice
+## qwen-tts
+- !!merge <<: *qwen-tts
+  name: "qwen-tts-development"
+  capabilities:
+    nvidia: "cuda12-qwen-tts-development"
+    intel: "intel-qwen-tts-development"
+    amd: "rocm-qwen-tts-development"
+    nvidia-l4t: "nvidia-l4t-qwen-tts-development"
+    default: "cpu-qwen-tts-development"
+    nvidia-cuda-13: "cuda13-qwen-tts-development"
+    nvidia-cuda-12: "cuda12-qwen-tts-development"
+    nvidia-l4t-cuda-12: "nvidia-l4t-qwen-tts-development"
+    nvidia-l4t-cuda-13: "cuda13-nvidia-l4t-arm64-qwen-tts-development"
+- !!merge <<: *qwen-tts
+  name: "cpu-qwen-tts"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-cpu-qwen-tts"
+  mirrors:
+    - localai/localai-backends:latest-cpu-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "cpu-qwen-tts-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-cpu-qwen-tts"
+  mirrors:
+    - localai/localai-backends:master-cpu-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "cuda12-qwen-tts"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-12-qwen-tts"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-12-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "cuda12-qwen-tts-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-12-qwen-tts"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-12-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "cuda13-qwen-tts"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-nvidia-cuda-13-qwen-tts"
+  mirrors:
+    - localai/localai-backends:latest-gpu-nvidia-cuda-13-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "cuda13-qwen-tts-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-nvidia-cuda-13-qwen-tts"
+  mirrors:
+    - localai/localai-backends:master-gpu-nvidia-cuda-13-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "intel-qwen-tts"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-intel-qwen-tts"
+  mirrors:
+    - localai/localai-backends:latest-gpu-intel-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "intel-qwen-tts-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-intel-qwen-tts"
+  mirrors:
+    - localai/localai-backends:master-gpu-intel-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "rocm-qwen-tts"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-gpu-rocm-hipblas-qwen-tts"
+  mirrors:
+    - localai/localai-backends:latest-gpu-rocm-hipblas-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "rocm-qwen-tts-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-gpu-rocm-hipblas-qwen-tts"
+  mirrors:
+    - localai/localai-backends:master-gpu-rocm-hipblas-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "nvidia-l4t-qwen-tts"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-nvidia-l4t-qwen-tts"
+  mirrors:
+    - localai/localai-backends:latest-nvidia-l4t-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "nvidia-l4t-qwen-tts-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-nvidia-l4t-qwen-tts"
+  mirrors:
+    - localai/localai-backends:master-nvidia-l4t-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "cuda13-nvidia-l4t-arm64-qwen-tts"
+  uri: "quay.io/go-skynet/local-ai-backends:latest-nvidia-l4t-cuda-13-arm64-qwen-tts"
+  mirrors:
+    - localai/localai-backends:latest-nvidia-l4t-cuda-13-arm64-qwen-tts
+- !!merge <<: *qwen-tts
+  name: "cuda13-nvidia-l4t-arm64-qwen-tts-development"
+  uri: "quay.io/go-skynet/local-ai-backends:master-nvidia-l4t-cuda-13-arm64-qwen-tts"
+  mirrors:
+    - localai/localai-backends:master-nvidia-l4t-cuda-13-arm64-qwen-tts
 ## pocket-tts
 - !!merge <<: *pocket-tts
   name: "pocket-tts-development"

backend/python/bark/requirements-intel.txt

@@ -1,8 +1,6 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.8.10+xpu
-torch==2.3.1+cxx11.abi
-torchaudio==2.3.1+cxx11.abi
-oneccl_bind_pt==2.3.100+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
+torchaudio
 optimum[openvino]
 setuptools
 transformers

backend/python/chatterbox/requirements-intel.txt

@@ -1,7 +1,6 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
-torch==2.3.1+cxx11.abi
-torchaudio==2.3.1+cxx11.abi
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
+torchaudio
 transformers
 numpy>=1.24.0,<1.26.0
 # https://github.com/mudler/LocalAI/pull/6240#issuecomment-3329518289

backend/python/common/libbackend.sh

@@ -398,7 +398,7 @@ function runProtogen() {
 # NOTE: for BUILD_PROFILE==intel, this function does NOT automatically use the Intel python package index.
 # you may want to add the following line to a requirements-intel.txt if you use one:
 #
-# --index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
+# --index-url https://download.pytorch.org/whl/xpu
 #
 # If you need to add extra flags into the pip install command you can do so by setting the variable EXTRA_PIP_INSTALL_FLAGS
 # before calling installRequirements.  For example:

backend/python/common/template/requirements-intel.txt

@@ -1,5 +1,4 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.8.10+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
 torch==2.8.0
 oneccl_bind_pt==2.8.0+xpu
 optimum[openvino]

backend/python/coqui/requirements-intel.txt

@@ -1,8 +1,6 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
-torch==2.3.1+cxx11.abi
-torchaudio==2.3.1+cxx11.abi
-oneccl_bind_pt==2.3.100+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch==2.8.0+xpu
+torchaudio==2.8.0+xpu
 optimum[openvino]
 setuptools
 transformers==4.48.3

backend/python/diffusers/backend.py

@@ -42,12 +42,8 @@ from transformers import T5EncoderModel
 from safetensors.torch import load_file
 
 # Import LTX-2 specific utilities
-try:
-    from diffusers.pipelines.ltx2.export_utils import encode_video as ltx2_encode_video
-    LTX2_AVAILABLE = True
-except ImportError:
-    LTX2_AVAILABLE = False
-    ltx2_encode_video = None
+from diffusers.pipelines.ltx2.export_utils import encode_video as ltx2_encode_video
+from diffusers import LTX2VideoTransformer3DModel, GGUFQuantizationConfig
 
 _ONE_DAY_IN_SECONDS = 60 * 60 * 24
 COMPEL = os.environ.get("COMPEL", "0") == "1"
@@ -302,12 +298,96 @@ class BackendServicer(backend_pb2_grpc.BackendServicer):
         if pipeline_type == "LTX2ImageToVideoPipeline":
             self.img2vid = True
             self.ltx2_pipeline = True
-            pipe = load_diffusers_pipeline(
-                class_name="LTX2ImageToVideoPipeline",
-                model_id=request.Model,
-                torch_dtype=torchType,
-                variant=variant
-            )
+            
+            # Check if loading from single file (GGUF)
+            if fromSingleFile and LTX2VideoTransformer3DModel is not None:
+                _, single_file_ext = os.path.splitext(modelFile)
+                if single_file_ext == ".gguf":
+                    # Load transformer from single GGUF file with quantization
+                    transformer_kwargs = {}
+                    quantization_config = GGUFQuantizationConfig(compute_dtype=torchType)
+                    transformer_kwargs["quantization_config"] = quantization_config
+                    
+                    transformer = LTX2VideoTransformer3DModel.from_single_file(
+                        modelFile,
+                        config=request.Model,  # Use request.Model as the config/model_id
+                        subfolder="transformer",
+                        **transformer_kwargs,
+                    )
+                    
+                    # Load pipeline with custom transformer
+                    pipe = load_diffusers_pipeline(
+                        class_name="LTX2ImageToVideoPipeline",
+                        model_id=request.Model,
+                        transformer=transformer,
+                        torch_dtype=torchType,
+                    )
+                else:
+                    # Single file but not GGUF - use standard single file loading
+                    pipe = load_diffusers_pipeline(
+                        class_name="LTX2ImageToVideoPipeline",
+                        model_id=modelFile,
+                        from_single_file=True,
+                        torch_dtype=torchType,
+                    )
+            else:
+                # Standard loading from pretrained
+                pipe = load_diffusers_pipeline(
+                    class_name="LTX2ImageToVideoPipeline",
+                    model_id=request.Model,
+                    torch_dtype=torchType,
+                    variant=variant
+                )
+            
+            if not DISABLE_CPU_OFFLOAD:
+                pipe.enable_model_cpu_offload()
+            return pipe
+
+        # LTX2Pipeline - text-to-video pipeline, needs txt2vid flag, CPU offload, and special handling
+        if pipeline_type == "LTX2Pipeline":
+            self.txt2vid = True
+            self.ltx2_pipeline = True
+            
+            # Check if loading from single file (GGUF)
+            if fromSingleFile and LTX2VideoTransformer3DModel is not None:
+                _, single_file_ext = os.path.splitext(modelFile)
+                if single_file_ext == ".gguf":
+                    # Load transformer from single GGUF file with quantization
+                    transformer_kwargs = {}
+                    quantization_config = GGUFQuantizationConfig(compute_dtype=torchType)
+                    transformer_kwargs["quantization_config"] = quantization_config
+                    
+                    transformer = LTX2VideoTransformer3DModel.from_single_file(
+                        modelFile,
+                        config=request.Model,  # Use request.Model as the config/model_id
+                        subfolder="transformer",
+                        **transformer_kwargs,
+                    )
+                    
+                    # Load pipeline with custom transformer
+                    pipe = load_diffusers_pipeline(
+                        class_name="LTX2Pipeline",
+                        model_id=request.Model,
+                        transformer=transformer,
+                        torch_dtype=torchType,
+                    )
+                else:
+                    # Single file but not GGUF - use standard single file loading
+                    pipe = load_diffusers_pipeline(
+                        class_name="LTX2Pipeline",
+                        model_id=modelFile,
+                        from_single_file=True,
+                        torch_dtype=torchType,
+                    )
+            else:
+                # Standard loading from pretrained
+                pipe = load_diffusers_pipeline(
+                    class_name="LTX2Pipeline",
+                    model_id=request.Model,
+                    torch_dtype=torchType,
+                    variant=variant
+                )
+            
             if not DISABLE_CPU_OFFLOAD:
                 pipe.enable_model_cpu_offload()
             return pipe
@@ -428,6 +508,8 @@ class BackendServicer(backend_pb2_grpc.BackendServicer):
             self.txt2vid = False
             self.ltx2_pipeline = False
 
+            print(f"LoadModel: PipelineType from request: {request.PipelineType}", file=sys.stderr)
+
             # Load pipeline using dynamic loader
             # Special cases that require custom initialization are handled first
             self.pipe = self._load_pipeline(
@@ -437,6 +519,8 @@ class BackendServicer(backend_pb2_grpc.BackendServicer):
                 torchType=torchType,
                 variant=variant
             )
+            
+            print(f"LoadModel: After loading - ltx2_pipeline: {self.ltx2_pipeline}, img2vid: {self.img2vid}, txt2vid: {self.txt2vid}, PipelineType: {self.PipelineType}", file=sys.stderr)
 
             if CLIPSKIP and request.CLIPSkip != 0:
                 self.clip_skip = request.CLIPSkip
@@ -674,14 +758,20 @@ class BackendServicer(backend_pb2_grpc.BackendServicer):
         try:
             prompt = request.prompt
             if not prompt:
+                print(f"GenerateVideo: No prompt provided for video generation.", file=sys.stderr)
                 return backend_pb2.Result(success=False, message="No prompt provided for video generation")
 
+            # Debug: Print raw request values
+            print(f"GenerateVideo: Raw request values - num_frames: {request.num_frames}, fps: {request.fps}, cfg_scale: {request.cfg_scale}, step: {request.step}", file=sys.stderr)
+
             # Set default values from request or use defaults
             num_frames = request.num_frames if request.num_frames > 0 else 81
             fps = request.fps if request.fps > 0 else 16
             cfg_scale = request.cfg_scale if request.cfg_scale > 0 else 4.0
             num_inference_steps = request.step if request.step > 0 else 40
             
+            print(f"GenerateVideo: Using values - num_frames: {num_frames}, fps: {fps}, cfg_scale: {cfg_scale}, num_inference_steps: {num_inference_steps}", file=sys.stderr)
+            
             # Prepare generation parameters
             kwargs = {
                 "prompt": prompt,
@@ -707,19 +797,34 @@ class BackendServicer(backend_pb2_grpc.BackendServicer):
                 kwargs["end_image"] = load_image(request.end_image)
 
             print(f"Generating video with {kwargs=}", file=sys.stderr)
+            print(f"GenerateVideo: Pipeline type: {self.PipelineType}, ltx2_pipeline flag: {self.ltx2_pipeline}", file=sys.stderr)
 
             # Generate video frames based on pipeline type
-            if self.ltx2_pipeline or self.PipelineType == "LTX2ImageToVideoPipeline":
-                # LTX-2 image-to-video generation with audio
-                if not LTX2_AVAILABLE:
-                    return backend_pb2.Result(success=False, message="LTX-2 pipeline requires diffusers.pipelines.ltx2.export_utils")
+            if self.ltx2_pipeline or self.PipelineType in ["LTX2Pipeline", "LTX2ImageToVideoPipeline"]:
+                # LTX-2 generation with audio (supports both text-to-video and image-to-video)
+                # Determine if this is text-to-video (no image) or image-to-video (has image)
+                has_image = bool(request.start_image)
                 
-                # LTX-2 uses 'image' parameter instead of 'start_image'
-                if request.start_image:
-                    image = load_image(request.start_image)
-                    kwargs["image"] = image
-                    # Remove start_image if it was added
-                    kwargs.pop("start_image", None)
+                # Remove image-related parameters that might have been added earlier
+                kwargs.pop("start_image", None)
+                kwargs.pop("end_image", None)
+                
+                # LTX2ImageToVideoPipeline uses 'image' parameter for image-to-video
+                # LTX2Pipeline (text-to-video) doesn't need an image parameter
+                if has_image:
+                    # Image-to-video: use 'image' parameter
+                    if self.PipelineType == "LTX2ImageToVideoPipeline":
+                        image = load_image(request.start_image)
+                        kwargs["image"] = image
+                        print(f"LTX-2: Using image-to-video mode with image", file=sys.stderr)
+                    else:
+                        # If pipeline type is LTX2Pipeline but we have an image, we can't do image-to-video
+                        return backend_pb2.Result(success=False, message="LTX2Pipeline does not support image-to-video. Use LTX2ImageToVideoPipeline for image-to-video generation.")
+                else:
+                    # Text-to-video: no image parameter needed
+                    # Ensure no image-related kwargs are present
+                    kwargs.pop("image", None)
+                    print(f"LTX-2: Using text-to-video mode (no image)", file=sys.stderr)
                 
                 # LTX-2 uses 'frame_rate' instead of 'fps'
                 frame_rate = float(fps)
@@ -730,20 +835,45 @@ class BackendServicer(backend_pb2_grpc.BackendServicer):
                 kwargs["return_dict"] = False
                 
                 # Generate video and audio
-                video, audio = self.pipe(**kwargs)
+                print(f"LTX-2: Generating with kwargs: {kwargs}", file=sys.stderr)
+                try:
+                    video, audio = self.pipe(**kwargs)
+                    print(f"LTX-2: Generated video shape: {video.shape}, audio shape: {audio.shape}", file=sys.stderr)
+                except Exception as e:
+                    print(f"LTX-2: Error during pipe() call: {e}", file=sys.stderr)
+                    traceback.print_exc()
+                    return backend_pb2.Result(success=False, message=f"Error generating video with LTX-2 pipeline: {e}")
                 
                 # Convert video to uint8 format
                 video = (video * 255).round().astype("uint8")
                 video = torch.from_numpy(video)
                 
+                print(f"LTX-2: Converting video, shape after conversion: {video.shape}", file=sys.stderr)
+                print(f"LTX-2: Audio sample rate: {self.pipe.vocoder.config.output_sampling_rate}", file=sys.stderr)
+                print(f"LTX-2: Output path: {request.dst}", file=sys.stderr)
+                
                 # Use LTX-2's encode_video function which handles audio
-                ltx2_encode_video(
-                    video[0],
-                    fps=frame_rate,
-                    audio=audio[0].float().cpu(),
-                    audio_sample_rate=self.pipe.vocoder.config.output_sampling_rate,
-                    output_path=request.dst,
-                )
+                try:
+                    ltx2_encode_video(
+                        video[0],
+                        fps=frame_rate,
+                        audio=audio[0].float().cpu(),
+                        audio_sample_rate=self.pipe.vocoder.config.output_sampling_rate,
+                        output_path=request.dst,
+                    )
+                    # Verify file was created and has content
+                    import os
+                    if os.path.exists(request.dst):
+                        file_size = os.path.getsize(request.dst)
+                        print(f"LTX-2: Video file created successfully, size: {file_size} bytes", file=sys.stderr)
+                        if file_size == 0:
+                            return backend_pb2.Result(success=False, message=f"Video file was created but is empty (0 bytes). Check LTX-2 encode_video function.")
+                    else:
+                        return backend_pb2.Result(success=False, message=f"Video file was not created at {request.dst}")
+                except Exception as e:
+                    print(f"LTX-2: Error encoding video: {e}", file=sys.stderr)
+                    traceback.print_exc()
+                    return backend_pb2.Result(success=False, message=f"Error encoding video: {e}")
                 
                 return backend_pb2.Result(message="Video generated successfully", success=True)
             elif self.PipelineType == "WanPipeline":
@@ -785,11 +915,23 @@ class BackendServicer(backend_pb2_grpc.BackendServicer):
                 output = self.pipe(**kwargs)
                 frames = output.frames[0]
             else:
+                print(f"GenerateVideo: Pipeline {self.PipelineType} does not match any known video pipeline handler", file=sys.stderr)
                 return backend_pb2.Result(success=False, message=f"Pipeline {self.PipelineType} does not support video generation")
 
             # Export video (for non-LTX-2 pipelines)
+            print(f"GenerateVideo: Exporting video to {request.dst} with fps={fps}", file=sys.stderr)
             export_to_video(frames, request.dst, fps=fps)
             
+            # Verify file was created
+            import os
+            if os.path.exists(request.dst):
+                file_size = os.path.getsize(request.dst)
+                print(f"GenerateVideo: Video file created, size: {file_size} bytes", file=sys.stderr)
+                if file_size == 0:
+                    return backend_pb2.Result(success=False, message=f"Video file was created but is empty (0 bytes)")
+            else:
+                return backend_pb2.Result(success=False, message=f"Video file was not created at {request.dst}")
+            
             return backend_pb2.Result(message="Video generated successfully", success=True)
 
         except Exception as err:

backend/python/diffusers/requirements-intel.txt

@@ -1,8 +1,6 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
-torch==2.5.1+cxx11.abi
-torchvision==0.20.1+cxx11.abi
-oneccl_bind_pt==2.8.0+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
+torchvision
 optimum[openvino]
 setuptools
 git+https://github.com/huggingface/diffusers

backend/python/diffusers/requirements.txt

@@ -3,3 +3,4 @@ grpcio==1.76.0
 pillow
 protobuf
 certifi
+av

backend/python/faster-whisper/requirements-intel.txt

@@ -1,6 +1,4 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
-torch==2.3.1+cxx11.abi
-oneccl_bind_pt==2.3.100+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
 optimum[openvino]
 faster-whisper

backend/python/kokoro/requirements-intel.txt

@@ -1,8 +1,6 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.8.10+xpu
-torch==2.5.1+cxx11.abi
-oneccl_bind_pt==2.8.0+xpu
-torchaudio==2.5.1+cxx11.abi
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
+torchaudio
 optimum[openvino]
 setuptools
 transformers==4.48.3

backend/python/pocket-tts/requirements-intel.txt

@@ -1,4 +1,4 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
+--extra-index-url https://download.pytorch.org/whl/xpu
 pocket-tts
 scipy
-torch==2.5.1+cxx11.abi
+torch

backend/python/qwen-tts/Makefile

@@ -0,0 +1,23 @@
+.PHONY: qwen-tts
+qwen-tts:
+	bash install.sh
+
+.PHONY: run
+run: qwen-tts
+	@echo "Running qwen-tts..."
+	bash run.sh
+	@echo "qwen-tts run."
+
+.PHONY: test
+test: qwen-tts
+	@echo "Testing qwen-tts..."
+	bash test.sh
+	@echo "qwen-tts tested."
+
+.PHONY: protogen-clean
+protogen-clean:
+	$(RM) backend_pb2_grpc.py backend_pb2.py
+
+.PHONY: clean
+clean: protogen-clean
+	rm -rf venv __pycache__

backend/python/qwen-tts/backend.py

@@ -0,0 +1,475 @@
+#!/usr/bin/env python3
+"""
+This is an extra gRPC server of LocalAI for Qwen3-TTS
+"""
+from concurrent import futures
+import time
+import argparse
+import signal
+import sys
+import os
+import copy
+import traceback
+from pathlib import Path
+import backend_pb2
+import backend_pb2_grpc
+import torch
+import soundfile as sf
+from qwen_tts import Qwen3TTSModel
+
+import grpc
+
+def is_float(s):
+    """Check if a string can be converted to float."""
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+def is_int(s):
+    """Check if a string can be converted to int."""
+    try:
+        int(s)
+        return True
+    except ValueError:
+        return False
+
+_ONE_DAY_IN_SECONDS = 60 * 60 * 24
+
+# If MAX_WORKERS are specified in the environment use it, otherwise default to 1
+MAX_WORKERS = int(os.environ.get('PYTHON_GRPC_MAX_WORKERS', '1'))
+
+
+# Implement the BackendServicer class with the service methods
+class BackendServicer(backend_pb2_grpc.BackendServicer):
+    """
+    BackendServicer is the class that implements the gRPC service
+    """
+    def Health(self, request, context):
+        return backend_pb2.Reply(message=bytes("OK", 'utf-8'))
+    
+    def LoadModel(self, request, context):
+        # Get device
+        if torch.cuda.is_available():
+            print("CUDA is available", file=sys.stderr)
+            device = "cuda"
+        else:
+            print("CUDA is not available", file=sys.stderr)
+            device = "cpu"
+        mps_available = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+        if mps_available:
+            device = "mps"
+        if not torch.cuda.is_available() and request.CUDA:
+            return backend_pb2.Result(success=False, message="CUDA is not available")
+
+        # Normalize potential 'mpx' typo to 'mps'
+        if device == "mpx":
+            print("Note: device 'mpx' detected, treating it as 'mps'.", file=sys.stderr)
+            device = "mps"
+        
+        # Validate mps availability if requested
+        if device == "mps" and not torch.backends.mps.is_available():
+            print("Warning: MPS not available. Falling back to CPU.", file=sys.stderr)
+            device = "cpu"
+
+        self.device = device
+        self._torch_device = torch.device(device)
+
+        options = request.Options
+
+        # empty dict
+        self.options = {}
+
+        # The options are a list of strings in this form optname:optvalue
+        # We are storing all the options in a dict so we can use it later when
+        # generating the audio
+        for opt in options:
+            if ":" not in opt:
+                continue
+            key, value = opt.split(":", 1)  # Split only on first colon
+            # if value is a number, convert it to the appropriate type
+            if is_float(value):
+                value = float(value)
+            elif is_int(value):
+                value = int(value)
+            elif value.lower() in ["true", "false"]:
+                value = value.lower() == "true"
+            self.options[key] = value
+
+        # Get model path from request
+        model_path = request.Model
+        if not model_path:
+            model_path = "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice"
+
+        # Determine model type from model path or options
+        self.model_type = self.options.get("model_type", None)
+        if not self.model_type:
+            if "CustomVoice" in model_path:
+                self.model_type = "CustomVoice"
+            elif "VoiceDesign" in model_path:
+                self.model_type = "VoiceDesign"
+            elif "Base" in model_path or "0.6B" in model_path or "1.7B" in model_path:
+                self.model_type = "Base"  # VoiceClone model
+            else:
+                # Default to CustomVoice
+                self.model_type = "CustomVoice"
+
+        # Cache for voice clone prompts
+        self._voice_clone_cache = {}
+
+        # Store AudioPath, ModelFile, and ModelPath from LoadModel request
+        # These are used later in TTS for VoiceClone mode
+        self.audio_path = request.AudioPath if hasattr(request, 'AudioPath') and request.AudioPath else None
+        self.model_file = request.ModelFile if hasattr(request, 'ModelFile') and request.ModelFile else None
+        self.model_path = request.ModelPath if hasattr(request, 'ModelPath') and request.ModelPath else None
+
+        # Decide dtype & attention implementation
+        if self.device == "mps":
+            load_dtype = torch.float32  # MPS requires float32
+            device_map = None
+            attn_impl_primary = "sdpa"  # flash_attention_2 not supported on MPS
+        elif self.device == "cuda":
+            load_dtype = torch.bfloat16
+            device_map = "cuda"
+            attn_impl_primary = "flash_attention_2"
+        else:  # cpu
+            load_dtype = torch.float32
+            device_map = "cpu"
+            attn_impl_primary = "sdpa"
+
+        print(f"Using device: {self.device}, torch_dtype: {load_dtype}, attn_implementation: {attn_impl_primary}, model_type: {self.model_type}", file=sys.stderr)
+        print(f"Loading model from: {model_path}", file=sys.stderr)
+
+        # Load model with device-specific logic
+        # Common parameters for all devices
+        load_kwargs = {
+            "dtype": load_dtype,
+            "attn_implementation": attn_impl_primary,
+            "trust_remote_code": True,  # Required for qwen-tts models
+        }
+        
+        try:
+            if self.device == "mps":
+                load_kwargs["device_map"] = None  # load then move
+                self.model = Qwen3TTSModel.from_pretrained(model_path, **load_kwargs)
+                self.model.to("mps")
+            elif self.device == "cuda":
+                load_kwargs["device_map"] = device_map
+                self.model = Qwen3TTSModel.from_pretrained(model_path, **load_kwargs)
+            else:  # cpu
+                load_kwargs["device_map"] = device_map
+                self.model = Qwen3TTSModel.from_pretrained(model_path, **load_kwargs)
+        except Exception as e:
+            error_msg = str(e)
+            print(f"[ERROR] Loading model: {type(e).__name__}: {error_msg}", file=sys.stderr)
+            print(traceback.format_exc(), file=sys.stderr)
+            
+            # Check if it's a missing feature extractor/tokenizer error
+            if "speech_tokenizer" in error_msg or "preprocessor_config.json" in error_msg or "feature extractor" in error_msg.lower():
+                print("\n[ERROR] Model files appear to be incomplete. This usually means:", file=sys.stderr)
+                print("  1. The model download was interrupted or incomplete", file=sys.stderr)
+                print("  2. The model cache is corrupted", file=sys.stderr)
+                print("\nTo fix this, try:", file=sys.stderr)
+                print(f"  rm -rf ~/.cache/huggingface/hub/models--Qwen--Qwen3-TTS-*", file=sys.stderr)
+                print("  Then re-run to trigger a fresh download.", file=sys.stderr)
+                print("\nAlternatively, try using a different model variant:", file=sys.stderr)
+                print("  - Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice", file=sys.stderr)
+                print("  - Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign", file=sys.stderr)
+                print("  - Qwen/Qwen3-TTS-12Hz-1.7B-Base", file=sys.stderr)
+            
+            if attn_impl_primary == 'flash_attention_2':
+                print("\nTrying to use SDPA instead of flash_attention_2...", file=sys.stderr)
+                load_kwargs["attn_implementation"] = 'sdpa'
+                try:
+                    if self.device == "mps":
+                        load_kwargs["device_map"] = None
+                        self.model = Qwen3TTSModel.from_pretrained(model_path, **load_kwargs)
+                        self.model.to("mps")
+                    else:
+                        load_kwargs["device_map"] = (self.device if self.device in ("cuda", "cpu") else None)
+                        self.model = Qwen3TTSModel.from_pretrained(model_path, **load_kwargs)
+                except Exception as e2:
+                    print(f"[ERROR] Failed to load with SDPA: {type(e2).__name__}: {e2}", file=sys.stderr)
+                    print(traceback.format_exc(), file=sys.stderr)
+                    raise e2
+            else:
+                raise e
+
+        print(f"Model loaded successfully: {model_path}", file=sys.stderr)
+
+        return backend_pb2.Result(message="Model loaded successfully", success=True)
+
+    def _detect_mode(self, request):
+        """Detect which mode to use based on request parameters."""
+        # Priority: VoiceClone > VoiceDesign > CustomVoice
+
+        # model_type explicitly set
+        if self.model_type == "CustomVoice":
+            return "CustomVoice"
+        if self.model_type == "VoiceClone":
+            return "VoiceClone"
+        if self.model_type == "VoiceDesign":
+            return "VoiceDesign"
+
+        # VoiceClone: AudioPath is provided (from LoadModel, stored in self.audio_path)
+        if self.audio_path:
+            return "VoiceClone"
+        
+        # VoiceDesign: instruct option is provided
+        if "instruct" in self.options and self.options["instruct"]:
+            return "VoiceDesign"
+        
+        # Default to CustomVoice
+        return "CustomVoice"
+
+    def _get_ref_audio_path(self, request):
+        """Get reference audio path from stored AudioPath (from LoadModel)."""
+        if not self.audio_path:
+            return None
+        
+        # If absolute path, use as-is
+        if os.path.isabs(self.audio_path):
+            return self.audio_path
+        
+        # Try relative to ModelFile
+        if self.model_file:
+            model_file_base = os.path.dirname(self.model_file)
+            ref_path = os.path.join(model_file_base, self.audio_path)
+            if os.path.exists(ref_path):
+                return ref_path
+        
+        # Try relative to ModelPath
+        if self.model_path:
+            ref_path = os.path.join(self.model_path, self.audio_path)
+            if os.path.exists(ref_path):
+                return ref_path
+        
+        # Return as-is (might be URL or base64)
+        return self.audio_path
+
+    def _get_voice_clone_prompt(self, request, ref_audio, ref_text):
+        """Get or create voice clone prompt, with caching."""
+        cache_key = f"{ref_audio}:{ref_text}"
+        
+        if cache_key not in self._voice_clone_cache:
+            print(f"Creating voice clone prompt from {ref_audio}", file=sys.stderr)
+            try:
+                prompt_items = self.model.create_voice_clone_prompt(
+                    ref_audio=ref_audio,
+                    ref_text=ref_text,
+                    x_vector_only_mode=self.options.get("x_vector_only_mode", False),
+                )
+                self._voice_clone_cache[cache_key] = prompt_items
+            except Exception as e:
+                print(f"Error creating voice clone prompt: {e}", file=sys.stderr)
+                print(traceback.format_exc(), file=sys.stderr)
+                return None
+        
+        return self._voice_clone_cache[cache_key]
+
+    def TTS(self, request, context):
+        try:
+            # Check if dst is provided
+            if not request.dst:
+                return backend_pb2.Result(
+                    success=False,
+                    message="dst (output path) is required"
+                )
+            
+            # Prepare text
+            text = request.text.strip()
+            if not text:
+                return backend_pb2.Result(
+                    success=False,
+                    message="Text is empty"
+                )
+
+            # Get language (auto-detect if not provided)
+            language = request.language if hasattr(request, 'language') and request.language else None
+            if not language or language == "":
+                language = "Auto"  # Auto-detect language
+
+            # Detect mode
+            mode = self._detect_mode(request)
+            print(f"Detected mode: {mode}", file=sys.stderr)
+
+            # Get generation parameters from options
+            max_new_tokens = self.options.get("max_new_tokens", None)
+            top_p = self.options.get("top_p", None)
+            temperature = self.options.get("temperature", None)
+            do_sample = self.options.get("do_sample", None)
+
+            # Prepare generation kwargs
+            generation_kwargs = {}
+            if max_new_tokens is not None:
+                generation_kwargs["max_new_tokens"] = max_new_tokens
+            if top_p is not None:
+                generation_kwargs["top_p"] = top_p
+            if temperature is not None:
+                generation_kwargs["temperature"] = temperature
+            if do_sample is not None:
+                generation_kwargs["do_sample"] = do_sample
+
+            instruct = self.options.get("instruct", "")
+            if instruct is not None and instruct != "":
+                generation_kwargs["instruct"] = instruct
+
+            # Generate audio based on mode
+            if mode == "VoiceClone":
+                # VoiceClone mode
+                ref_audio = self._get_ref_audio_path(request)
+                if not ref_audio:
+                    return backend_pb2.Result(
+                        success=False,
+                        message="AudioPath is required for VoiceClone mode"
+                    )
+                
+                ref_text = self.options.get("ref_text", None)
+                if not ref_text:
+                    # Try to get from request if available
+                    if hasattr(request, 'ref_text') and request.ref_text:
+                        ref_text = request.ref_text
+                    else:
+                        # x_vector_only_mode doesn't require ref_text
+                        if not self.options.get("x_vector_only_mode", False):
+                            return backend_pb2.Result(
+                                success=False,
+                                message="ref_text is required for VoiceClone mode (or set x_vector_only_mode=true)"
+                            )
+
+                # Check if we should use cached prompt
+                use_cached_prompt = self.options.get("use_cached_prompt", True)
+                voice_clone_prompt = None
+                
+                if use_cached_prompt:
+                    voice_clone_prompt = self._get_voice_clone_prompt(request, ref_audio, ref_text)
+                    if voice_clone_prompt is None:
+                        return backend_pb2.Result(
+                            success=False,
+                            message="Failed to create voice clone prompt"
+                        )
+
+                if voice_clone_prompt:
+                    # Use cached prompt
+                    wavs, sr = self.model.generate_voice_clone(
+                        text=text,
+                        language=language,
+                        voice_clone_prompt=voice_clone_prompt,
+                        **generation_kwargs
+                    )
+                else:
+                    # Create prompt on-the-fly
+                    wavs, sr = self.model.generate_voice_clone(
+                        text=text,
+                        language=language,
+                        ref_audio=ref_audio,
+                        ref_text=ref_text,
+                        x_vector_only_mode=self.options.get("x_vector_only_mode", False),
+                        **generation_kwargs
+                    )
+
+            elif mode == "VoiceDesign":
+                # VoiceDesign mode
+                if not instruct:
+                    return backend_pb2.Result(
+                        success=False,
+                        message="instruct option is required for VoiceDesign mode"
+                    )
+
+                wavs, sr = self.model.generate_voice_design(
+                    text=text,
+                    language=language,
+                    instruct=instruct,
+                    **generation_kwargs
+                )
+
+            else:
+                # CustomVoice mode (default)
+                speaker = request.voice if request.voice else None
+                if not speaker:
+                    # Try to get from options
+                    speaker = self.options.get("speaker", None)
+                    if not speaker:
+                        # Use default speaker
+                        speaker = "Vivian"
+                        print(f"No speaker specified, using default: {speaker}", file=sys.stderr)
+
+                # Validate speaker if model supports it
+                if hasattr(self.model, 'get_supported_speakers'):
+                    try:
+                        supported_speakers = self.model.get_supported_speakers()
+                        if speaker not in supported_speakers:
+                            print(f"Warning: Speaker '{speaker}' not in supported list. Available: {supported_speakers}", file=sys.stderr)
+                            # Try to find a close match (case-insensitive)
+                            speaker_lower = speaker.lower()
+                            for sup_speaker in supported_speakers:
+                                if sup_speaker.lower() == speaker_lower:
+                                    speaker = sup_speaker
+                                    print(f"Using matched speaker: {speaker}", file=sys.stderr)
+                                    break
+                    except Exception as e:
+                        print(f"Warning: Could not get supported speakers: {e}", file=sys.stderr)
+
+                wavs, sr = self.model.generate_custom_voice(
+                    text=text,
+                    language=language,
+                    speaker=speaker,
+                    **generation_kwargs
+                )
+
+            # Save output
+            if wavs is not None and len(wavs) > 0:
+                # wavs is a list, take first element
+                audio_data = wavs[0] if isinstance(wavs, list) else wavs
+                sf.write(request.dst, audio_data, sr)
+                print(f"Saved output to {request.dst}", file=sys.stderr)
+            else:
+                return backend_pb2.Result(
+                    success=False,
+                    message="No audio output generated"
+                )
+
+        except Exception as err:
+            print(f"Error in TTS: {err}", file=sys.stderr)
+            print(traceback.format_exc(), file=sys.stderr)
+            return backend_pb2.Result(success=False, message=f"Unexpected {err=}, {type(err)=}")
+        
+        return backend_pb2.Result(success=True)
+
+def serve(address):
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=MAX_WORKERS),
+        options=[
+            ('grpc.max_message_length', 50 * 1024 * 1024),  # 50MB
+            ('grpc.max_send_message_length', 50 * 1024 * 1024),  # 50MB
+            ('grpc.max_receive_message_length', 50 * 1024 * 1024),  # 50MB
+        ])
+    backend_pb2_grpc.add_BackendServicer_to_server(BackendServicer(), server)
+    server.add_insecure_port(address)
+    server.start()
+    print("Server started. Listening on: " + address, file=sys.stderr)
+
+    # Define the signal handler function
+    def signal_handler(sig, frame):
+        print("Received termination signal. Shutting down...")
+        server.stop(0)
+        sys.exit(0)
+
+    # Set the signal handlers for SIGINT and SIGTERM
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    try:
+        while True:
+            time.sleep(_ONE_DAY_IN_SECONDS)
+    except KeyboardInterrupt:
+        server.stop(0)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the gRPC server.")
+    parser.add_argument(
+        "--addr", default="localhost:50051", help="The address to bind the server to."
+    )
+    args = parser.parse_args()
+
+    serve(args.addr)

backend/python/qwen-tts/install.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+EXTRA_PIP_INSTALL_FLAGS="--no-build-isolation"
+
+backend_dir=$(dirname $0)
+if [ -d $backend_dir/common ]; then
+    source $backend_dir/common/libbackend.sh
+else
+    source $backend_dir/../common/libbackend.sh
+fi
+
+installRequirements

backend/python/qwen-tts/requirements-cpu.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch
+torchaudio
+qwen-tts
+sox

backend/python/qwen-tts/requirements-cublas12-after.txt

@@ -0,0 +1 @@
+flash-attn

backend/python/qwen-tts/requirements-cublas12.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/cu121
+torch
+torchaudio
+qwen-tts
+sox

backend/python/qwen-tts/requirements-cublas13.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/cu130
+torch
+torchaudio
+qwen-tts
+sox

backend/python/qwen-tts/requirements-hipblas.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/rocm6.3
+torch==2.7.1+rocm6.3
+torchaudio==2.7.1+rocm6.3
+qwen-tts
+sox

backend/python/qwen-tts/requirements-intel-after.txt

@@ -0,0 +1 @@
+flash-attn

backend/python/qwen-tts/requirements-intel.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
+torchaudio
+qwen-tts
+sox

backend/python/qwen-tts/requirements-l4t12.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://pypi.jetson-ai-lab.io/jp6/cu129/
+torch
+torchaudio
+qwen-tts
+sox

backend/python/qwen-tts/requirements-l4t13.txt

@@ -0,0 +1,5 @@
+--extra-index-url https://download.pytorch.org/whl/cu130
+torch
+torchaudio
+qwen-tts
+sox

backend/python/qwen-tts/requirements-mps.txt

@@ -0,0 +1,4 @@
+torch==2.7.1
+torchaudio==0.22.1
+qwen-tts
+sox

backend/python/qwen-tts/requirements.txt

@@ -0,0 +1,6 @@
+grpcio==1.71.0
+protobuf
+certifi
+packaging==24.1
+soundfile
+setuptools

backend/python/qwen-tts/run.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+backend_dir=$(dirname $0)
+if [ -d $backend_dir/common ]; then
+    source $backend_dir/common/libbackend.sh
+else
+    source $backend_dir/../common/libbackend.sh
+fi
+
+startBackend $@

backend/python/qwen-tts/test.py

@@ -0,0 +1,98 @@
+"""
+A test script to test the gRPC service
+"""
+import unittest
+import subprocess
+import time
+import os
+import sys
+import tempfile
+import threading
+import backend_pb2
+import backend_pb2_grpc
+
+import grpc
+
+
+class TestBackendServicer(unittest.TestCase):
+    """
+    TestBackendServicer is the class that tests the gRPC service
+    """
+    def setUp(self):
+        """
+        This method sets up the gRPC service by starting the server
+        """
+        self.service = subprocess.Popen(
+            ["python3", "backend.py", "--addr", "localhost:50051"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        time.sleep(5)
+
+    def tearDown(self) -> None:
+        """
+        This method tears down the gRPC service by terminating the server
+        """
+        self.service.terminate()
+        try:
+            stdout, stderr = self.service.communicate(timeout=5)
+            # Output should already be printed by threads, but print any remaining
+            if stdout:
+                print("=== REMAINING STDOUT ===")
+                print(stdout)
+            if stderr:
+                print("=== REMAINING STDERR ===")
+                print(stderr)
+        except subprocess.TimeoutExpired:
+            self.service.kill()
+            stdout, stderr = self.service.communicate()
+            if stdout:
+                print("=== REMAINING STDOUT ===")
+                print(stdout)
+            if stderr:
+                print("=== REMAINING STDERR ===")
+                print(stderr)
+
+    def test_tts(self):
+        """
+        This method tests if the TTS generation works successfully
+        """
+        try:
+            self.setUp()
+            with grpc.insecure_channel("localhost:50051") as channel:
+                stub = backend_pb2_grpc.BackendStub(channel)
+                # Allow up to 10 minutes for model download on first run
+                response = stub.LoadModel(
+                    backend_pb2.ModelOptions(Model="Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice"),
+                    timeout=600.0
+                )
+                self.assertTrue(response.success)
+                
+                # Create temporary output file
+                with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp_file:
+                    output_path = tmp_file.name
+                
+                tts_request = backend_pb2.TTSRequest(
+                    text="Hello, this is a test of the qwen-tts backend.",
+                    voice="Vivian",
+                    dst=output_path
+                )
+                # Allow up to 2 minutes for TTS generation
+                tts_response = stub.TTS(tts_request, timeout=120.0)
+                self.assertIsNotNone(tts_response)
+                self.assertTrue(tts_response.success)
+                
+                # Verify output file exists and is not empty
+                self.assertTrue(os.path.exists(output_path))
+                self.assertGreater(os.path.getsize(output_path), 0)
+                
+                # Cleanup
+                os.unlink(output_path)
+        except Exception as err:
+            print(f"Exception: {err}", file=sys.stderr)
+            # Give threads a moment to flush any remaining output
+            time.sleep(1)
+            self.fail("TTS service failed")
+        finally:
+            self.tearDown()

backend/python/qwen-tts/test.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -e
+
+backend_dir=$(dirname $0)
+if [ -d $backend_dir/common ]; then
+    source $backend_dir/common/libbackend.sh
+else
+    source $backend_dir/../common/libbackend.sh
+fi
+
+runUnittests

backend/python/rerankers/requirements-intel.txt

@@ -1,9 +1,7 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
 transformers
 accelerate
-torch==2.3.1+cxx11.abi
-oneccl_bind_pt==2.8.0+xpu
+torch
 rerankers[transformers]
 optimum[openvino]
 setuptools

backend/python/rfdetr/requirements-intel.txt

@@ -1,8 +1,6 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
-torch==2.3.1+cxx11.abi
-torchvision==0.18.1+cxx11.abi
-oneccl_bind_pt==2.3.100+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
+torchvision
 optimum[openvino]
 setuptools
 rfdetr

backend/python/transformers/requirements-intel.txt

@@ -1,12 +1,9 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
-torch==2.5.1+cxx11.abi
-oneccl_bind_pt==2.8.0+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
 optimum[openvino]
 llvmlite==0.43.0
 numba==0.60.0
 transformers
-intel-extension-for-transformers
 bitsandbytes
 outetts
 sentence-transformers==5.2.0

backend/python/vibevoice/requirements-intel.txt

@@ -1,8 +1,6 @@
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.3.110+xpu
-torch==2.5.1+cxx11.abi
-torchvision==0.20.1+cxx11.abi
-oneccl_bind_pt==2.8.0+xpu
+--extra-index-url https://download.pytorch.org/whl/xpu
+torch
+torchvision
 optimum[openvino]
 setuptools
 git+https://github.com/huggingface/diffusers

backend/python/vllm/requirements-intel.txt

@@ -1,10 +1,7 @@
 --extra-index-url https://download.pytorch.org/whl/xpu
---extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
-intel-extension-for-pytorch==2.7.10+xpu
 accelerate
-torch==2.7.0+xpu
+torch
 transformers
 optimum[openvino]
 setuptools
-bitsandbytes
-oneccl_bind_pt==2.7.0+xpu
+bitsandbytes

core/backend/llm.go

@@ -61,6 +61,18 @@ func ModelInference(ctx context.Context, s string, messages schema.Messages, ima
 		return nil, err
 	}
 
+	// Detect thinking support after model load (only if not already detected)
+	// This needs to happen after LoadModel succeeds so the backend can render templates
+	if (c.ReasoningConfig.DisableReasoning == nil && c.ReasoningConfig.DisableReasoningTagPrefill == nil) && c.TemplateConfig.UseTokenizerTemplate {
+		modelOpts := grpcModelOpts(*c, o.SystemState.Model.ModelsPath)
+		config.DetectThinkingSupportFromBackend(ctx, c, inferenceModel, modelOpts)
+		// Update the config in the loader so it persists for future requests
+		cl.UpdateModelConfig(c.Name, func(cfg *config.ModelConfig) {
+			cfg.ReasoningConfig.DisableReasoning = c.ReasoningConfig.DisableReasoning
+			cfg.ReasoningConfig.DisableReasoningTagPrefill = c.ReasoningConfig.DisableReasoningTagPrefill
+		})
+	}
+
 	var protoMessages []*proto.Message
 	// if we are using the tokenizer template, we need to convert the messages to proto messages
 	// unless the prompt has already been tokenized (non-chat endpoints + functions)

core/config/gguf.go

@@ -1,10 +1,16 @@
 package config
 
 import (
+	"context"
+
+	"github.com/mudler/LocalAI/pkg/grpc"
+	pb "github.com/mudler/LocalAI/pkg/grpc/proto"
+	"github.com/mudler/LocalAI/pkg/reasoning"
 	"github.com/mudler/LocalAI/pkg/xsysinfo"
 	"github.com/mudler/xlog"
 
 	gguf "github.com/gpustack/gguf-parser-go"
+	"github.com/gpustack/gguf-parser-go/util/ptr"
 )
 
 const (
@@ -62,16 +68,25 @@ func guessGGUFFromFile(cfg *ModelConfig, f *gguf.GGUFFile, defaultCtx int) {
 		cfg.NGPULayers = &defaultHigh
 	}
 
-	xlog.Debug("guessDefaultsFromFile: NGPULayers set", "NGPULayers", cfg.NGPULayers)
+	xlog.Debug("[gguf] guessDefaultsFromFile: NGPULayers set", "NGPULayers", cfg.NGPULayers, "modelName", f.Metadata().Name)
+
+	// identify from well known templates first, otherwise use the raw jinja template
+	chatTemplate, found := f.Header.MetadataKV.Get("tokenizer.chat_template")
+	if found {
+		// fill jinja template
+		cfg.modelTemplate = chatTemplate.ValueString()
+	}
+
+	// Thinking support detection is done after model load via DetectThinkingSupportFromBackend
 
 	// template estimations
 	if cfg.HasTemplate() {
 		// nothing to guess here
-		xlog.Debug("guessDefaultsFromFile: template already set", "name", cfg.Name)
+		xlog.Debug("[gguf] guessDefaultsFromFile: template already set", "name", cfg.Name, "modelName", f.Metadata().Name)
 		return
 	}
 
-	xlog.Debug("Model file loaded", "file", cfg.ModelFileName(), "eosTokenID", f.Tokenizer().EOSTokenID, "bosTokenID", f.Tokenizer().BOSTokenID, "modelName", f.Metadata().Name, "architecture", f.Architecture().Architecture)
+	xlog.Debug("[gguf] Model file loaded", "file", cfg.ModelFileName(), "eosTokenID", f.Tokenizer().EOSTokenID, "bosTokenID", f.Tokenizer().BOSTokenID, "modelName", f.Metadata().Name, "architecture", f.Architecture().Architecture)
 
 	// guess the name
 	if cfg.Name == "" {
@@ -83,4 +98,49 @@ func guessGGUFFromFile(cfg *ModelConfig, f *gguf.GGUFFile, defaultCtx int) {
 	cfg.FunctionsConfig.GrammarConfig.NoGrammar = true
 	cfg.Options = append(cfg.Options, "use_jinja:true")
 	cfg.KnownUsecaseStrings = append(cfg.KnownUsecaseStrings, "FLAG_CHAT")
+
+}
+
+// DetectThinkingSupportFromBackend calls the ModelMetadata gRPC method to detect
+// if the model supports thinking mode and if the template ends with a thinking start token.
+// This should be called after the model is loaded.
+// The results are stored in cfg.SupportsThinking and cfg.ThinkingForcedOpen.
+func DetectThinkingSupportFromBackend(ctx context.Context, cfg *ModelConfig, backendClient grpc.Backend, modelOptions *pb.ModelOptions) {
+	if backendClient == nil {
+		xlog.Debug("[gguf] DetectThinkingSupportFromBackend: backend client is nil, skipping detection")
+		return
+	}
+
+	if modelOptions == nil {
+		xlog.Debug("[gguf] DetectThinkingSupportFromBackend: model options is nil, skipping detection")
+		return
+	}
+
+	// Only detect for llama-cpp backend when using tokenizer templates
+	if cfg.Backend != "llama-cpp" || !cfg.TemplateConfig.UseTokenizerTemplate {
+		xlog.Debug("[gguf] DetectThinkingSupportFromBackend: skipping detection", "backend", cfg.Backend, "useTokenizerTemplate", cfg.TemplateConfig.UseTokenizerTemplate)
+		return
+	}
+
+	metadata, err := backendClient.ModelMetadata(ctx, modelOptions)
+	if err != nil {
+		xlog.Warn("[gguf] DetectThinkingSupportFromBackend: failed to get model metadata", "error", err)
+		return
+	}
+
+	if metadata != nil {
+		cfg.ReasoningConfig.DisableReasoning = ptr.To(!metadata.SupportsThinking)
+
+		// Use the rendered template to detect if thinking token is at the end
+		// This reuses the existing DetectThinkingStartToken function
+		if metadata.RenderedTemplate != "" {
+			thinkingStartToken := reasoning.DetectThinkingStartToken(metadata.RenderedTemplate, &cfg.ReasoningConfig)
+			thinkingForcedOpen := thinkingStartToken != ""
+			cfg.ReasoningConfig.DisableReasoningTagPrefill = ptr.To(!thinkingForcedOpen)
+			xlog.Debug("[gguf] DetectThinkingSupportFromBackend: thinking support detected", "supports_thinking", metadata.SupportsThinking, "thinking_forced_open", thinkingForcedOpen, "thinking_start_token", thinkingStartToken)
+		} else {
+			cfg.ReasoningConfig.DisableReasoningTagPrefill = ptr.To(true)
+			xlog.Debug("[gguf] DetectThinkingSupportFromBackend: thinking support detected", "supports_thinking", metadata.SupportsThinking, "thinking_forced_open", false)
+		}
+	}
 }

core/config/model_config.go

@@ -31,6 +31,7 @@ type TTSConfig struct {
 // @Description ModelConfig represents a model configuration
 type ModelConfig struct {
 	modelConfigFile          string `yaml:"-" json:"-"`
+	modelTemplate            string `yaml:"-" json:"-"`
 	schema.PredictionOptions `yaml:"parameters,omitempty" json:"parameters,omitempty"`
 	Name                     string `yaml:"name,omitempty" json:"name,omitempty"`
 
@@ -52,7 +53,7 @@ type ModelConfig struct {
 	ResponseFormatMap                          map[string]interface{} `yaml:"-" json:"-"`
 
 	FunctionsConfig functions.FunctionsConfig `yaml:"function,omitempty" json:"function,omitempty"`
-	ReasoningConfig reasoning.ReasoningConfig `yaml:"reasoning,omitempty" json:"reasoning,omitempty"`
+	ReasoningConfig reasoning.Config          `yaml:"reasoning,omitempty" json:"reasoning,omitempty"`
 
 	FeatureFlag FeatureFlag `yaml:"feature_flags,omitempty" json:"feature_flags,omitempty"` // Feature Flag registry. We move fast, and features may break on a per model/backend basis. Registry for (usually temporary) flags that indicate aborting something early.
 	// LLM configs (GPT4ALL, Llama.cpp, ...)
@@ -523,6 +524,11 @@ func (c *ModelConfig) GetModelConfigFile() string {
 	return c.modelConfigFile
 }
 
+// GetModelTemplate returns the model's chat template if available
+func (c *ModelConfig) GetModelTemplate() string {
+	return c.modelTemplate
+}
+
 type ModelConfigUsecase int
 
 const (

core/config/model_config_loader.go

@@ -246,6 +246,17 @@ func (bcl *ModelConfigLoader) RemoveModelConfig(m string) {
 	delete(bcl.configs, m)
 }
 
+// UpdateModelConfig updates an existing model config in the loader.
+// This is useful for updating runtime-detected properties like thinking support.
+func (bcl *ModelConfigLoader) UpdateModelConfig(m string, updater func(*ModelConfig)) {
+	bcl.Lock()
+	defer bcl.Unlock()
+	if cfg, exists := bcl.configs[m]; exists {
+		updater(&cfg)
+		bcl.configs[m] = cfg
+	}
+}
+
 // Preload prepare models if they are not local but url or huggingface repositories
 func (bcl *ModelConfigLoader) Preload(modelPath string) error {
 	bcl.Lock()

core/http/endpoints/localai/video.go

@@ -167,6 +167,16 @@ func VideoEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfi
 
 		baseURL := middleware.BaseURL(c)
 
+		xlog.Debug("VideoEndpoint: Calling VideoGeneration",
+			"num_frames", input.NumFrames,
+			"fps", input.FPS,
+			"cfg_scale", input.CFGScale,
+			"step", input.Step,
+			"seed", input.Seed,
+			"width", width,
+			"height", height,
+			"negative_prompt", input.NegativePrompt)
+
 		fn, err := backend.VideoGeneration(
 			height,
 			width,

core/http/endpoints/openai/chat.go

@@ -13,7 +13,7 @@ import (
 	"github.com/mudler/LocalAI/core/http/middleware"
 	"github.com/mudler/LocalAI/core/schema"
 	"github.com/mudler/LocalAI/pkg/functions"
-	"github.com/mudler/LocalAI/pkg/reasoning"
+	reason "github.com/mudler/LocalAI/pkg/reasoning"
 
 	"github.com/mudler/LocalAI/core/templates"
 	"github.com/mudler/LocalAI/pkg/model"
@@ -39,24 +39,25 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 		}
 		responses <- initialMessage
 
+		// Detect if thinking token is already in prompt or template
+		// When UseTokenizerTemplate is enabled, predInput is empty, so we check the template
+		var template string
+		if config.TemplateConfig.UseTokenizerTemplate {
+			template = config.GetModelTemplate()
+		} else {
+			template = s
+		}
+		thinkingStartToken := reason.DetectThinkingStartToken(template, &config.ReasoningConfig)
+
 		// Track accumulated content for reasoning extraction
 		accumulatedContent := ""
 		lastEmittedReasoning := ""
 		lastEmittedCleanedContent := ""
 
-		// Configure reasoning extraction options
-		// Auto-detect if prompt ends with thinking tag
-		// or use explicit config setting
-		thinkingForcedOpen := config.ReasoningConfig.ThinkingForcedOpen || reasoning.DetectThinkingForcedOpen(s)
-
 		_, _, err := ComputeChoices(req, s, config, cl, startupOptions, loader, func(s string, c *[]schema.Choice) {}, func(s string, tokenUsage backend.TokenUsage) bool {
 			accumulatedContent += s
-			// Extract reasoning from accumulated content
-			opts := []reasoning.Option{}
-			if thinkingForcedOpen {
-				opts = append(opts, reasoning.WithThinkingForcedOpen())
-			}
-			currentReasoning, cleanedContent := reasoning.Extract(accumulatedContent, opts...)
+
+			currentReasoning, cleanedContent := reason.ExtractReasoningWithConfig(accumulatedContent, thinkingStartToken, config.ReasoningConfig)
 
 			// Calculate new reasoning delta (what we haven't emitted yet)
 			var reasoningDelta *string
@@ -128,6 +129,15 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 		return err
 	}
 	processTools := func(noAction string, prompt string, req *schema.OpenAIRequest, config *config.ModelConfig, loader *model.ModelLoader, responses chan schema.OpenAIResponse, extraUsage bool) error {
+		// Detect if thinking token is already in prompt or template
+		var template string
+		if config.TemplateConfig.UseTokenizerTemplate {
+			template = config.GetModelTemplate()
+		} else {
+			template = prompt
+		}
+		thinkingStartToken := reason.DetectThinkingStartToken(template, &config.ReasoningConfig)
+
 		result := ""
 		lastEmittedCount := 0
 		_, tokenUsage, err := ComputeChoices(req, prompt, config, cl, startupOptions, loader, func(s string, c *[]schema.Choice) {}, func(s string, usage backend.TokenUsage) bool {
@@ -239,15 +249,8 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 		if err != nil {
 			return err
 		}
-		// Extract reasoning before processing tool calls
-		// Auto-detect if prompt ends with thinking tag or use explicit config
-		toolsThinkingForcedOpen := config.ReasoningConfig.ThinkingForcedOpen || reasoning.DetectThinkingForcedOpen(prompt)
-		opts := []reasoning.Option{}
-		if toolsThinkingForcedOpen {
-			opts = append(opts, reasoning.WithThinkingForcedOpen())
-		}
-		extractedReasoning, cleanedResult := reasoning.Extract(result, opts...)
-		result = cleanedResult
+		// Prepend thinking token if needed, then extract reasoning before processing tool calls
+		reasoning, result := reason.ExtractReasoningWithConfig(result, thinkingStartToken, config.ReasoningConfig)
 
 		textContentToReturn = functions.ParseTextContent(result, config.FunctionsConfig)
 		result = functions.CleanupLLMResult(result, config.FunctionsConfig)
@@ -282,8 +285,8 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 			}
 
 			var deltaReasoning *string
-			if extractedReasoning != "" {
-				deltaReasoning = &extractedReasoning
+			if reasoning != "" {
+				deltaReasoning = &reasoning
 			}
 			delta := &schema.Message{Content: &result}
 			if deltaReasoning != nil {
@@ -633,25 +636,27 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 
 		// no streaming mode
 		default:
+			// Detect if thinking token is already in prompt or template
+			var template string
+			if config.TemplateConfig.UseTokenizerTemplate {
+				template = config.GetModelTemplate() // TODO: this should be the parsed jinja template. But for now this is the best we can do.
+			} else {
+				template = predInput
+			}
+			thinkingStartToken := reason.DetectThinkingStartToken(template, &config.ReasoningConfig)
 
-			// Auto-detect if prompt ends with thinking tag for non-streaming mode
-			nonStreamThinkingForcedOpen := config.ReasoningConfig.ThinkingForcedOpen || reasoning.DetectThinkingForcedOpen(predInput)
+			xlog.Debug("Thinking start token", "thinkingStartToken", thinkingStartToken, "template", template)
 
 			tokenCallback := func(s string, c *[]schema.Choice) {
-				// Extract reasoning from the response
-				var extractedReasoning string
-				opts := []reasoning.Option{}
-				if nonStreamThinkingForcedOpen {
-					opts = append(opts, reasoning.WithThinkingForcedOpen())
-				}
-				extractedReasoning, s = reasoning.Extract(s, opts...)
+				// Prepend thinking token if needed, then extract reasoning from the response
+				reasoning, s := reason.ExtractReasoningWithConfig(s, thinkingStartToken, config.ReasoningConfig)
 
 				if !shouldUseFn {
 					// no function is called, just reply and use stop as finish reason
 					stopReason := FinishReasonStop
 					message := &schema.Message{Role: "assistant", Content: &s}
-					if extractedReasoning != "" {
-						message.Reasoning = &extractedReasoning
+					if reasoning != "" {
+						message.Reasoning = &reasoning
 					}
 					*c = append(*c, schema.Choice{FinishReason: &stopReason, Index: 0, Message: message})
 					return
@@ -673,8 +678,8 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 
 					stopReason := FinishReasonStop
 					message := &schema.Message{Role: "assistant", Content: &result}
-					if extractedReasoning != "" {
-						message.Reasoning = &extractedReasoning
+					if reasoning != "" {
+						message.Reasoning = &reasoning
 					}
 					*c = append(*c, schema.Choice{
 						FinishReason: &stopReason,
@@ -687,8 +692,8 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 							Role: "assistant",
 						},
 					}
-					if extractedReasoning != "" {
-						toolChoice.Message.Reasoning = &extractedReasoning
+					if reasoning != "" {
+						toolChoice.Message.Reasoning = &reasoning
 					}
 
 					for _, ss := range results {
@@ -718,8 +723,8 @@ func ChatEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, evaluator
 									"arguments": args,
 								},
 							}
-							if extractedReasoning != "" {
-								message.Reasoning = &extractedReasoning
+							if reasoning != "" {
+								message.Reasoning = &reasoning
 							}
 							*c = append(*c, schema.Choice{
 								FinishReason: &functionCallReason,

core/http/endpoints/openai/video.go

@@ -1,140 +0,0 @@
-package openai
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/labstack/echo/v4"
-	"github.com/mudler/LocalAI/core/config"
-	"github.com/mudler/LocalAI/core/http/endpoints/localai"
-	"github.com/mudler/LocalAI/core/http/middleware"
-	"github.com/mudler/LocalAI/core/schema"
-	model "github.com/mudler/LocalAI/pkg/model"
-)
-
-func VideoEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfig *config.ApplicationConfig) echo.HandlerFunc {
-	return func(c echo.Context) error {
-		input, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_LOCALAI_REQUEST).(*schema.OpenAIRequest)
-		if !ok || input == nil {
-			return echo.ErrBadRequest
-		}
-		var raw map[string]interface{}
-		body := make([]byte, 0)
-		if c.Request().Body != nil {
-			c.Request().Body.Read(body)
-		}
-		if len(body) > 0 {
-			_ = json.Unmarshal(body, &raw)
-		}
-		// Build VideoRequest using shared mapper
-		vr := MapOpenAIToVideo(input, raw)
-		// Place VideoRequest into context so localai.VideoEndpoint can consume it
-		c.Set(middleware.CONTEXT_LOCALS_KEY_LOCALAI_REQUEST, vr)
-		// Delegate to existing localai handler
-		return localai.VideoEndpoint(cl, ml, appConfig)(c)
-	}
-}
-
-// VideoEndpoint godoc
-// @Summary Generate a video from an OpenAI-compatible request
-// @Description Accepts an OpenAI-style request and delegates to the LocalAI video generator
-// @Tags openai
-// @Accept json
-// @Produce json
-// @Param request body schema.OpenAIRequest true "OpenAI-style request"
-// @Success 200 {object} map[string]interface{}
-// @Failure 400 {object} map[string]interface{}
-// @Router /v1/videos [post]
-
-func MapOpenAIToVideo(input *schema.OpenAIRequest, raw map[string]interface{}) *schema.VideoRequest {
-	vr := &schema.VideoRequest{}
-	if input == nil {
-		return vr
-	}
-
-	if input.Model != "" {
-		vr.Model = input.Model
-	}
-
-	// Prompt mapping
-	switch p := input.Prompt.(type) {
-	case string:
-		vr.Prompt = p
-	case []interface{}:
-		if len(p) > 0 {
-			if s, ok := p[0].(string); ok {
-				vr.Prompt = s
-			}
-		}
-	}
-
-	// Size
-	size := input.Size
-	if size == "" && raw != nil {
-		if v, ok := raw["size"].(string); ok {
-			size = v
-		}
-	}
-	if size != "" {
-		parts := strings.SplitN(size, "x", 2)
-		if len(parts) == 2 {
-			if wi, err := strconv.Atoi(parts[0]); err == nil {
-				vr.Width = int32(wi)
-			}
-			if hi, err := strconv.Atoi(parts[1]); err == nil {
-				vr.Height = int32(hi)
-			}
-		}
-	}
-
-	// seconds -> num frames
-	secondsStr := ""
-	if raw != nil {
-		if v, ok := raw["seconds"].(string); ok {
-			secondsStr = v
-		} else if v, ok := raw["seconds"].(float64); ok {
-			secondsStr = fmt.Sprintf("%v", int(v))
-		}
-	}
-	fps := int32(30)
-	if raw != nil {
-		if rawFPS, ok := raw["fps"]; ok {
-			switch rf := rawFPS.(type) {
-			case float64:
-				fps = int32(rf)
-			case string:
-				if fi, err := strconv.Atoi(rf); err == nil {
-					fps = int32(fi)
-				}
-			}
-		}
-	}
-	if secondsStr != "" {
-		if secF, err := strconv.Atoi(secondsStr); err == nil {
-			vr.FPS = fps
-			vr.NumFrames = int32(secF) * fps
-		}
-	}
-
-	// input_reference
-	if raw != nil {
-		if v, ok := raw["input_reference"].(string); ok {
-			vr.StartImage = v
-		}
-	}
-
-	// response format
-	if input.ResponseFormat != nil {
-		if rf, ok := input.ResponseFormat.(string); ok {
-			vr.ResponseFormat = rf
-		}
-	}
-
-	if input.Step != 0 {
-		vr.Step = int32(input.Step)
-	}
-
-	return vr
-}

core/http/endpoints/openresponses/responses.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"strings"
 	"time"
 
 	"github.com/google/uuid"
@@ -18,6 +19,7 @@ import (
 	"github.com/mudler/LocalAI/core/templates"
 	"github.com/mudler/LocalAI/pkg/functions"
 	"github.com/mudler/LocalAI/pkg/model"
+	reason "github.com/mudler/LocalAI/pkg/reasoning"
 	"github.com/mudler/LocalAI/pkg/utils"
 	"github.com/mudler/cogito"
 	"github.com/mudler/xlog"
@@ -1330,13 +1332,37 @@ func handleOpenResponsesNonStream(c echo.Context, responseID string, createdAt i
 	result := backend.Finetune(*cfg, predInput, prediction.Response)
 	xlog.Debug("Open Responses - Raw model result", "result", result, "shouldUseFn", shouldUseFn)
 
+	// Detect if thinking token is already in prompt or template
+	var template string
+	if cfg.TemplateConfig.UseTokenizerTemplate {
+		template = cfg.GetModelTemplate()
+	} else {
+		template = predInput
+	}
+	thinkingStartToken := reason.DetectThinkingStartToken(template, &cfg.ReasoningConfig)
+
+	// Extract reasoning from result before cleaning
+	reasoningContent, cleanedResult := reason.ExtractReasoningWithConfig(result, thinkingStartToken, cfg.ReasoningConfig)
+
 	// Parse tool calls if using functions
 	var outputItems []schema.ORItemField
 	var toolCalls []schema.ToolCall
 
+	// Add reasoning item if reasoning was found (reasoning comes first per spec)
+	if reasoningContent != "" {
+		reasoningItem := schema.ORItemField{
+			Type:    "reasoning",
+			ID:      fmt.Sprintf("reasoning_%s", uuid.New().String()),
+			Status:  "completed",
+			Content: []schema.ORContentPart{makeOutputTextPart(reasoningContent)},
+		}
+		outputItems = append(outputItems, reasoningItem)
+		xlog.Debug("Open Responses - Extracted reasoning", "reasoning_length", len(reasoningContent))
+	}
+
 	if shouldUseFn {
-		// Clean up the result first (handle reasoning tags, etc.)
-		cleanedResult := functions.CleanupLLMResult(result, cfg.FunctionsConfig)
+		// Clean up the result (already extracted reasoning above)
+		cleanedResult = functions.CleanupLLMResult(cleanedResult, cfg.FunctionsConfig)
 		xlog.Debug("Open Responses - Cleaned result", "cleanedResult", cleanedResult)
 
 		funcCallResults := functions.ParseFunctionCall(cleanedResult, cfg.FunctionsConfig)
@@ -1398,28 +1424,46 @@ func handleOpenResponsesNonStream(c echo.Context, responseID string, createdAt i
 			})
 		}
 
-		// If we have no output items but the model did produce output, include the raw result as a message
+		// If we have no output items but the model did produce output, include the cleaned result as a message
 		// This handles cases where the function call parsing failed but we still have model output
-		if len(outputItems) == 0 && result != "" {
-			xlog.Debug("Open Responses - No parsed output, falling back to raw result")
+		// Note: reasoning item may already be added above
+		hasMessageItem := false
+		for _, item := range outputItems {
+			if item.Type == "message" {
+				hasMessageItem = true
+				break
+			}
+		}
+		if !hasMessageItem && cleanedResult != "" {
+			xlog.Debug("Open Responses - No parsed output, falling back to cleaned result")
 			outputItems = append(outputItems, schema.ORItemField{
 				Type:    "message",
 				ID:      fmt.Sprintf("msg_%s", uuid.New().String()),
 				Status:  "completed",
 				Role:    "assistant",
-				Content: []schema.ORContentPart{makeOutputTextPartWithLogprobs(result, prediction.Logprobs)},
+				Content: []schema.ORContentPart{makeOutputTextPartWithLogprobs(cleanedResult, prediction.Logprobs)},
 			})
 		}
 	} else {
 		// Simple text response (include logprobs if available)
-		outputItems = []schema.ORItemField{
-			{
-				Type:    "message",
-				ID:      fmt.Sprintf("msg_%s", uuid.New().String()),
-				Status:  "completed",
-				Role:    "assistant",
-				Content: []schema.ORContentPart{makeOutputTextPartWithLogprobs(result, prediction.Logprobs)},
-			},
+		// Note: reasoning item may already be added above
+		messageItem := schema.ORItemField{
+			Type:    "message",
+			ID:      fmt.Sprintf("msg_%s", uuid.New().String()),
+			Status:  "completed",
+			Role:    "assistant",
+			Content: []schema.ORContentPart{makeOutputTextPartWithLogprobs(cleanedResult, prediction.Logprobs)},
+		}
+		outputItems = append(outputItems, messageItem)
+	}
+
+	// Calculate reasoning tokens (approximate: character count / 4)
+	reasoningTokens := 0
+	if reasoningContent != "" {
+		// Simple estimation: ~4 characters per token
+		reasoningTokens = len(reasoningContent) / 4
+		if reasoningTokens == 0 && len(reasoningContent) > 0 {
+			reasoningTokens = 1
 		}
 	}
 
@@ -1429,6 +1473,9 @@ func handleOpenResponsesNonStream(c echo.Context, responseID string, createdAt i
 		InputTokens:  prediction.Usage.Prompt,
 		OutputTokens: prediction.Usage.Completion,
 		TotalTokens:  prediction.Usage.Prompt + prediction.Usage.Completion,
+		OutputTokensDetails: &schema.OROutputTokensDetails{
+			ReasoningTokens: reasoningTokens,
+		},
 	}, shouldStore)
 
 	// Store response for future reference (if enabled)
@@ -1484,6 +1531,15 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 		}
 	}
 
+	// Detect if thinking token is already in prompt or template
+	var template string
+	if cfg.TemplateConfig.UseTokenizerTemplate {
+		template = cfg.GetModelTemplate()
+	} else {
+		template = predInput
+	}
+	thinkingStartToken := reason.DetectThinkingStartToken(template, &cfg.ReasoningConfig)
+
 	// Track state for streaming
 	var currentMessageID string
 	var currentContentIndex int
@@ -1492,6 +1548,14 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 	outputIndex := 0
 	inToolCallMode := false
 
+	// Track reasoning state for streaming
+	var currentReasoningID string
+	var currentReasoningContentIndex int
+	var accumulatedContent string
+	var lastEmittedReasoning string
+	var lastEmittedCleanedContent string
+	var reasoningTokens int
+
 	// Collect all output items for storage
 	var collectedOutputItems []schema.ORItemField
 
@@ -1646,52 +1710,133 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 				return true
 			}
 
-			// If no tool calls detected yet, emit text delta
+			// If no tool calls detected yet, handle reasoning and text
 			if !inToolCallMode {
-				if currentMessageID == "" {
-					// Emit output_item.added for message
-					currentMessageID = fmt.Sprintf("msg_%s", uuid.New().String())
-					messageItem := &schema.ORItemField{
-						Type:    "message",
-						ID:      currentMessageID,
-						Status:  "in_progress",
-						Role:    "assistant",
-						Content: []schema.ORContentPart{},
-					}
-					sendSSEEvent(c, &schema.ORStreamEvent{
-						Type:           "response.output_item.added",
-						SequenceNumber: sequenceNumber,
-						OutputIndex:    &outputIndex,
-						Item:           messageItem,
-					})
-					sequenceNumber++
+				accumulatedContent += token
+				currentReasoning, cleanedContent := reason.ExtractReasoningWithConfig(accumulatedContent, thinkingStartToken, cfg.ReasoningConfig)
 
-					// Emit content_part.added
-					currentContentIndex = 0
-					emptyPart := makeOutputTextPart("")
+				// Handle reasoning item
+				if currentReasoning != "" {
+					// Check if we need to create reasoning item
+					if currentReasoningID == "" {
+						outputIndex++
+						currentReasoningID = fmt.Sprintf("reasoning_%s", uuid.New().String())
+						reasoningItem := &schema.ORItemField{
+							Type:   "reasoning",
+							ID:     currentReasoningID,
+							Status: "in_progress",
+						}
+						sendSSEEvent(c, &schema.ORStreamEvent{
+							Type:           "response.output_item.added",
+							SequenceNumber: sequenceNumber,
+							OutputIndex:    &outputIndex,
+							Item:           reasoningItem,
+						})
+						sequenceNumber++
+
+						// Emit content_part.added for reasoning
+						currentReasoningContentIndex = 0
+						emptyPart := makeOutputTextPart("")
+						sendSSEEvent(c, &schema.ORStreamEvent{
+							Type:           "response.content_part.added",
+							SequenceNumber: sequenceNumber,
+							ItemID:         currentReasoningID,
+							OutputIndex:    &outputIndex,
+							ContentIndex:   &currentReasoningContentIndex,
+							Part:           &emptyPart,
+						})
+						sequenceNumber++
+					}
+
+					// Calculate reasoning delta
+					var reasoningDelta string
+					if len(currentReasoning) > len(lastEmittedReasoning) && strings.HasPrefix(currentReasoning, lastEmittedReasoning) {
+						reasoningDelta = currentReasoning[len(lastEmittedReasoning):]
+						lastEmittedReasoning = currentReasoning
+					} else if currentReasoning != lastEmittedReasoning {
+						reasoningDelta = currentReasoning
+						lastEmittedReasoning = currentReasoning
+					}
+
+					// Emit reasoning delta if there's new content
+					if reasoningDelta != "" {
+						sendSSEEvent(c, &schema.ORStreamEvent{
+							Type:           "response.output_text.delta",
+							SequenceNumber: sequenceNumber,
+							ItemID:         currentReasoningID,
+							OutputIndex:    &outputIndex,
+							ContentIndex:   &currentReasoningContentIndex,
+							Delta:          strPtr(reasoningDelta),
+							Logprobs:       emptyLogprobs(),
+						})
+						sequenceNumber++
+						c.Response().Flush()
+					}
+				}
+
+				// Handle message content (cleaned content without reasoning tags)
+				var deltaContent string
+				if len(cleanedContent) > len(lastEmittedCleanedContent) && strings.HasPrefix(cleanedContent, lastEmittedCleanedContent) {
+					deltaContent = cleanedContent[len(lastEmittedCleanedContent):]
+					lastEmittedCleanedContent = cleanedContent
+				} else if cleanedContent != lastEmittedCleanedContent {
+					if lastEmittedCleanedContent == "" {
+						deltaContent = cleanedContent
+						lastEmittedCleanedContent = cleanedContent
+					} else {
+						deltaContent = cleanedContent
+						lastEmittedCleanedContent = cleanedContent
+					}
+				}
+
+				// Only emit message content if there's actual content (not just reasoning)
+				if deltaContent != "" {
+					if currentMessageID == "" {
+						// Emit output_item.added for message
+						outputIndex++
+						currentMessageID = fmt.Sprintf("msg_%s", uuid.New().String())
+						messageItem := &schema.ORItemField{
+							Type:    "message",
+							ID:      currentMessageID,
+							Status:  "in_progress",
+							Role:    "assistant",
+							Content: []schema.ORContentPart{},
+						}
+						sendSSEEvent(c, &schema.ORStreamEvent{
+							Type:           "response.output_item.added",
+							SequenceNumber: sequenceNumber,
+							OutputIndex:    &outputIndex,
+							Item:           messageItem,
+						})
+						sequenceNumber++
+
+						// Emit content_part.added
+						currentContentIndex = 0
+						emptyPart := makeOutputTextPart("")
+						sendSSEEvent(c, &schema.ORStreamEvent{
+							Type:           "response.content_part.added",
+							SequenceNumber: sequenceNumber,
+							ItemID:         currentMessageID,
+							OutputIndex:    &outputIndex,
+							ContentIndex:   &currentContentIndex,
+							Part:           &emptyPart,
+						})
+						sequenceNumber++
+					}
+
+					// Emit text delta
 					sendSSEEvent(c, &schema.ORStreamEvent{
-						Type:           "response.content_part.added",
+						Type:           "response.output_text.delta",
 						SequenceNumber: sequenceNumber,
 						ItemID:         currentMessageID,
 						OutputIndex:    &outputIndex,
 						ContentIndex:   &currentContentIndex,
-						Part:           &emptyPart,
+						Delta:          strPtr(deltaContent),
+						Logprobs:       emptyLogprobs(),
 					})
 					sequenceNumber++
+					c.Response().Flush()
 				}
-
-				// Emit text delta
-				sendSSEEvent(c, &schema.ORStreamEvent{
-					Type:           "response.output_text.delta",
-					SequenceNumber: sequenceNumber,
-					ItemID:         currentMessageID,
-					OutputIndex:    &outputIndex,
-					ContentIndex:   &currentContentIndex,
-					Delta:          strPtr(token),
-					Logprobs:       emptyLogprobs(),
-				})
-				sequenceNumber++
-				c.Response().Flush()
 			}
 			return true
 		}
@@ -1754,7 +1899,62 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 		}
 
 		result := backend.Finetune(*cfg, predInput, prediction.Response)
-		cleanedResult := functions.CleanupLLMResult(result, cfg.FunctionsConfig)
+
+		// Extract reasoning from final result
+		finalReasoning, finalCleanedResult := reason.ExtractReasoningWithConfig(result, thinkingStartToken, cfg.ReasoningConfig)
+
+		// Close reasoning item if it exists and wasn't closed yet
+		if currentReasoningID != "" && finalReasoning != "" {
+			// Emit output_text.done for reasoning
+			sendSSEEvent(c, &schema.ORStreamEvent{
+				Type:           "response.output_text.done",
+				SequenceNumber: sequenceNumber,
+				ItemID:         currentReasoningID,
+				OutputIndex:    &outputIndex,
+				ContentIndex:   &currentReasoningContentIndex,
+				Text:           strPtr(finalReasoning),
+				Logprobs:       emptyLogprobs(),
+			})
+			sequenceNumber++
+
+			// Emit content_part.done for reasoning
+			reasoningPart := makeOutputTextPart(finalReasoning)
+			sendSSEEvent(c, &schema.ORStreamEvent{
+				Type:           "response.content_part.done",
+				SequenceNumber: sequenceNumber,
+				ItemID:         currentReasoningID,
+				OutputIndex:    &outputIndex,
+				ContentIndex:   &currentReasoningContentIndex,
+				Part:           &reasoningPart,
+			})
+			sequenceNumber++
+
+			// Emit output_item.done for reasoning
+			reasoningItem := &schema.ORItemField{
+				Type:    "reasoning",
+				ID:      currentReasoningID,
+				Status:  "completed",
+				Content: []schema.ORContentPart{reasoningPart},
+			}
+			sendSSEEvent(c, &schema.ORStreamEvent{
+				Type:           "response.output_item.done",
+				SequenceNumber: sequenceNumber,
+				OutputIndex:    &outputIndex,
+				Item:           reasoningItem,
+			})
+			sequenceNumber++
+
+			// Collect reasoning item for storage
+			collectedOutputItems = append(collectedOutputItems, *reasoningItem)
+
+			// Calculate reasoning tokens
+			reasoningTokens = len(finalReasoning) / 4
+			if reasoningTokens == 0 && len(finalReasoning) > 0 {
+				reasoningTokens = 1
+			}
+		}
+
+		cleanedResult := functions.CleanupLLMResult(finalCleanedResult, cfg.FunctionsConfig)
 		xlog.Debug("Open Responses Stream - Cleaned result", "cleanedResult", cleanedResult)
 
 		parsedToolCalls := functions.ParseFunctionCall(cleanedResult, cfg.FunctionsConfig)
@@ -1789,10 +1989,10 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 		// Convert prediction logprobs for streaming events
 		streamEventLogprobs := convertLogprobsForStreaming(prediction.Logprobs)
 
-		// If we have no output but the model did produce something, use the raw result
-		if textContent == "" && len(toolCalls) == 0 && result != "" {
-			xlog.Debug("Open Responses Stream - No parsed output, using raw result")
-			textContent = result
+		// If we have no output but the model did produce something, use the cleaned result (without reasoning tags)
+		if textContent == "" && len(toolCalls) == 0 && finalCleanedResult != "" {
+			xlog.Debug("Open Responses Stream - No parsed output, using cleaned result")
+			textContent = finalCleanedResult
 		}
 
 		// Close message if we have text content
@@ -1875,8 +2075,18 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 			collectedOutputItems = append(collectedOutputItems, *functionCallItem)
 		}
 
-		// Build final response with all items (include logprobs)
+		// Build final response with all items (include reasoning first, then messages, then tool calls)
 		var allOutputItems []schema.ORItemField
+		// Add reasoning item if it exists
+		if currentReasoningID != "" && finalReasoning != "" {
+			allOutputItems = append(allOutputItems, schema.ORItemField{
+				Type:    "reasoning",
+				ID:      currentReasoningID,
+				Status:  "completed",
+				Content: []schema.ORContentPart{makeOutputTextPart(finalReasoning)},
+			})
+		}
+		// Add message item
 		if currentMessageID != "" && textContent != "" {
 			allOutputItems = append(allOutputItems, schema.ORItemField{
 				Type:    "message",
@@ -1886,6 +2096,7 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 				Content: []schema.ORContentPart{makeOutputTextPartWithLogprobs(textContent, prediction.Logprobs)},
 			})
 		}
+		// Add tool call items
 		for _, tc := range toolCalls {
 			toolCallID := fmt.Sprintf("fc_%s", uuid.New().String())
 			allOutputItems = append(allOutputItems, schema.ORItemField{
@@ -1904,6 +2115,9 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 			InputTokens:  prediction.Usage.Prompt,
 			OutputTokens: prediction.Usage.Completion,
 			TotalTokens:  prediction.Usage.Prompt + prediction.Usage.Completion,
+			OutputTokensDetails: &schema.OROutputTokensDetails{
+				ReasoningTokens: reasoningTokens,
+			},
 		}, shouldStore)
 
 		sendSSEEvent(c, &schema.ORStreamEvent{
@@ -1956,22 +2170,102 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 	})
 	sequenceNumber++
 
-	// Stream text deltas
+	// Stream text deltas with reasoning extraction
 	tokenCallback := func(token string, tokenUsage backend.TokenUsage) bool {
 		accumulatedText += token
+		accumulatedContent += token
+		// Prepend thinking token if needed, then extract reasoning
+		currentReasoning, cleanedContent := reason.ExtractReasoningWithConfig(accumulatedContent, thinkingStartToken, cfg.ReasoningConfig)
 
-		// Emit text delta
-		sendSSEEvent(c, &schema.ORStreamEvent{
-			Type:           "response.output_text.delta",
-			SequenceNumber: sequenceNumber,
-			ItemID:         currentMessageID,
-			OutputIndex:    &outputIndex,
-			ContentIndex:   &currentContentIndex,
-			Delta:          strPtr(token),
-			Logprobs:       emptyLogprobs(),
-		})
-		sequenceNumber++
-		c.Response().Flush()
+		// Handle reasoning item
+		if currentReasoning != "" {
+			// Check if we need to create reasoning item
+			if currentReasoningID == "" {
+				outputIndex++
+				currentReasoningID = fmt.Sprintf("reasoning_%s", uuid.New().String())
+				reasoningItem := &schema.ORItemField{
+					Type:   "reasoning",
+					ID:     currentReasoningID,
+					Status: "in_progress",
+				}
+				sendSSEEvent(c, &schema.ORStreamEvent{
+					Type:           "response.output_item.added",
+					SequenceNumber: sequenceNumber,
+					OutputIndex:    &outputIndex,
+					Item:           reasoningItem,
+				})
+				sequenceNumber++
+
+				// Emit content_part.added for reasoning
+				currentReasoningContentIndex = 0
+				emptyPart := makeOutputTextPart("")
+				sendSSEEvent(c, &schema.ORStreamEvent{
+					Type:           "response.content_part.added",
+					SequenceNumber: sequenceNumber,
+					ItemID:         currentReasoningID,
+					OutputIndex:    &outputIndex,
+					ContentIndex:   &currentReasoningContentIndex,
+					Part:           &emptyPart,
+				})
+				sequenceNumber++
+			}
+
+			// Calculate reasoning delta
+			var reasoningDelta string
+			if len(currentReasoning) > len(lastEmittedReasoning) && strings.HasPrefix(currentReasoning, lastEmittedReasoning) {
+				reasoningDelta = currentReasoning[len(lastEmittedReasoning):]
+				lastEmittedReasoning = currentReasoning
+			} else if currentReasoning != lastEmittedReasoning {
+				reasoningDelta = currentReasoning
+				lastEmittedReasoning = currentReasoning
+			}
+
+			// Emit reasoning delta if there's new content
+			if reasoningDelta != "" {
+				sendSSEEvent(c, &schema.ORStreamEvent{
+					Type:           "response.output_text.delta",
+					SequenceNumber: sequenceNumber,
+					ItemID:         currentReasoningID,
+					OutputIndex:    &outputIndex,
+					ContentIndex:   &currentReasoningContentIndex,
+					Delta:          strPtr(reasoningDelta),
+					Logprobs:       emptyLogprobs(),
+				})
+				sequenceNumber++
+				c.Response().Flush()
+			}
+		}
+
+		// Handle message content (cleaned content without reasoning tags)
+		var deltaContent string
+		if len(cleanedContent) > len(lastEmittedCleanedContent) && strings.HasPrefix(cleanedContent, lastEmittedCleanedContent) {
+			deltaContent = cleanedContent[len(lastEmittedCleanedContent):]
+			lastEmittedCleanedContent = cleanedContent
+		} else if cleanedContent != lastEmittedCleanedContent {
+			if lastEmittedCleanedContent == "" {
+				deltaContent = cleanedContent
+				lastEmittedCleanedContent = cleanedContent
+			} else {
+				deltaContent = cleanedContent
+				lastEmittedCleanedContent = cleanedContent
+			}
+		}
+
+		// Only emit message content if there's actual content (not just reasoning)
+		if deltaContent != "" {
+			// Emit text delta
+			sendSSEEvent(c, &schema.ORStreamEvent{
+				Type:           "response.output_text.delta",
+				SequenceNumber: sequenceNumber,
+				ItemID:         currentMessageID,
+				OutputIndex:    &outputIndex,
+				ContentIndex:   &currentContentIndex,
+				Delta:          strPtr(deltaContent),
+				Logprobs:       emptyLogprobs(),
+			})
+			sequenceNumber++
+			c.Response().Flush()
+		}
 		return true
 	}
 
@@ -2034,6 +2328,62 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 
 	result := backend.Finetune(*cfg, predInput, prediction.Response)
 
+	// Extract reasoning from final result for non-tool-call path
+	finalReasoning, finalCleanedResult := reason.ExtractReasoningWithConfig(result, thinkingStartToken, cfg.ReasoningConfig)
+
+	// Close reasoning item if it exists and wasn't closed yet
+	if currentReasoningID != "" && finalReasoning != "" {
+		// Emit output_text.done for reasoning
+		sendSSEEvent(c, &schema.ORStreamEvent{
+			Type:           "response.output_text.done",
+			SequenceNumber: sequenceNumber,
+			ItemID:         currentReasoningID,
+			OutputIndex:    &outputIndex,
+			ContentIndex:   &currentReasoningContentIndex,
+			Text:           strPtr(finalReasoning),
+			Logprobs:       emptyLogprobs(),
+		})
+		sequenceNumber++
+
+		// Emit content_part.done for reasoning
+		reasoningPart := makeOutputTextPart(finalReasoning)
+		sendSSEEvent(c, &schema.ORStreamEvent{
+			Type:           "response.content_part.done",
+			SequenceNumber: sequenceNumber,
+			ItemID:         currentReasoningID,
+			OutputIndex:    &outputIndex,
+			ContentIndex:   &currentReasoningContentIndex,
+			Part:           &reasoningPart,
+		})
+		sequenceNumber++
+
+		// Emit output_item.done for reasoning
+		reasoningItem := &schema.ORItemField{
+			Type:    "reasoning",
+			ID:      currentReasoningID,
+			Status:  "completed",
+			Content: []schema.ORContentPart{reasoningPart},
+		}
+		sendSSEEvent(c, &schema.ORStreamEvent{
+			Type:           "response.output_item.done",
+			SequenceNumber: sequenceNumber,
+			OutputIndex:    &outputIndex,
+			Item:           reasoningItem,
+		})
+		sequenceNumber++
+
+		// Collect reasoning item for storage
+		collectedOutputItems = append(collectedOutputItems, *reasoningItem)
+
+		// Calculate reasoning tokens
+		reasoningTokens = len(finalReasoning) / 4
+		if reasoningTokens == 0 && len(finalReasoning) > 0 {
+			reasoningTokens = 1
+		}
+	}
+
+	result = finalCleanedResult
+
 	// Convert prediction logprobs for streaming events
 	mcpStreamLogprobs := convertLogprobsForStreaming(prediction.Logprobs)
 
@@ -2075,17 +2425,35 @@ func handleOpenResponsesStream(c echo.Context, responseID string, createdAt int6
 	// Emit response.completed
 	now := time.Now().Unix()
 
-	// Collect final output items (use collected items if available, otherwise use messageItem)
+	// Collect final output items (reasoning first, then message)
 	var finalOutputItems []schema.ORItemField
+	// Add reasoning item if it exists
+	if currentReasoningID != "" && finalReasoning != "" {
+		finalOutputItems = append(finalOutputItems, schema.ORItemField{
+			Type:    "reasoning",
+			ID:      currentReasoningID,
+			Status:  "completed",
+			Content: []schema.ORContentPart{makeOutputTextPart(finalReasoning)},
+		})
+	}
+	// Add message item
 	if len(collectedOutputItems) > 0 {
-		finalOutputItems = collectedOutputItems
+		// Use collected items (may include reasoning already)
+		for _, item := range collectedOutputItems {
+			if item.Type == "message" {
+				finalOutputItems = append(finalOutputItems, item)
+			}
+		}
 	} else {
-		finalOutputItems = []schema.ORItemField{*messageItem}
+		finalOutputItems = append(finalOutputItems, *messageItem)
 	}
 	responseCompleted := buildORResponse(responseID, createdAt, &now, "completed", input, finalOutputItems, &schema.ORUsage{
 		InputTokens:  prediction.Usage.Prompt,
 		OutputTokens: prediction.Usage.Completion,
 		TotalTokens:  prediction.Usage.Prompt + prediction.Usage.Completion,
+		OutputTokensDetails: &schema.OROutputTokensDetails{
+			ReasoningTokens: reasoningTokens,
+		},
 	}, shouldStore)
 	sendSSEEvent(c, &schema.ORStreamEvent{
 		Type:           "response.completed",

core/http/middleware/trace.go

@@ -36,6 +36,7 @@ type APIExchange struct {
 var traceBuffer *circularbuffer.Queue[APIExchange]
 var mu sync.Mutex
 var logChan = make(chan APIExchange, 100)
+var initOnce sync.Once
 
 type bodyWriter struct {
 	http.ResponseWriter
@@ -53,26 +54,37 @@ func (w *bodyWriter) Flush() {
 	}
 }
 
-// TraceMiddleware intercepts and logs JSON API requests and responses
-func TraceMiddleware(app *application.Application) echo.MiddlewareFunc {
-	if app.ApplicationConfig().EnableTracing && traceBuffer == nil {
-		traceBuffer = circularbuffer.New[APIExchange](app.ApplicationConfig().TracingMaxItems)
+func initializeTracing(maxItems int) {
+	initOnce.Do(func() {
+		if maxItems <= 0 {
+			maxItems = 100
+		}
+		mu.Lock()
+		traceBuffer = circularbuffer.New[APIExchange](maxItems)
+		mu.Unlock()
 
 		go func() {
 			for exchange := range logChan {
 				mu.Lock()
-				traceBuffer.Enqueue(exchange)
+				if traceBuffer != nil {
+					traceBuffer.Enqueue(exchange)
+				}
 				mu.Unlock()
 			}
 		}()
-	}
+	})
+}
 
+// TraceMiddleware intercepts and logs JSON API requests and responses
+func TraceMiddleware(app *application.Application) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			if !app.ApplicationConfig().EnableTracing {
 				return next(c)
 			}
 
+			initializeTracing(app.ApplicationConfig().TracingMaxItems)
+
 			if c.Request().Header.Get("Content-Type") != "application/json" {
 				return next(c)
 			}
@@ -138,6 +150,10 @@ func TraceMiddleware(app *application.Application) echo.MiddlewareFunc {
 // GetTraces returns a copy of the logged API exchanges for display
 func GetTraces() []APIExchange {
 	mu.Lock()
+	if traceBuffer == nil {
+		mu.Unlock()
+		return []APIExchange{}
+	}
 	traces := traceBuffer.Values()
 	mu.Unlock()
 
@@ -151,6 +167,8 @@ func GetTraces() []APIExchange {
 // ClearTraces clears the in-memory logs
 func ClearTraces() {
 	mu.Lock()
-	traceBuffer.Clear()
+	if traceBuffer != nil {
+		traceBuffer.Clear()
+	}
 	mu.Unlock()
 }

core/http/openai_mapping_test.go

@@ -1,75 +0,0 @@
-package http_test
-
-import (
-	"encoding/json"
-
-	openai "github.com/mudler/LocalAI/core/http/endpoints/openai"
-	"github.com/mudler/LocalAI/core/schema"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("MapOpenAIToVideo", func() {
-	It("maps size and seconds correctly", func() {
-		cases := []struct {
-			name     string
-			input    *schema.OpenAIRequest
-			raw      map[string]interface{}
-			expectsW int32
-			expectsH int32
-			expectsF int32
-			expectsN int32
-		}{
-			{
-				name: "size in input",
-				input: &schema.OpenAIRequest{
-					PredictionOptions: schema.PredictionOptions{
-						BasicModelRequest: schema.BasicModelRequest{Model: "m"},
-					},
-					Size: "256x128",
-				},
-				expectsW: 256,
-				expectsH: 128,
-			},
-			{
-				name:  "size in raw and seconds as string",
-				input: &schema.OpenAIRequest{PredictionOptions: schema.PredictionOptions{BasicModelRequest: schema.BasicModelRequest{Model: "m"}}},
-				raw:   map[string]interface{}{"size": "720x480", "seconds": "2"},
-				expectsW: 720,
-				expectsH: 480,
-				expectsF: 30,
-				expectsN: 60,
-			},
-			{
-				name:  "seconds as number and fps override",
-				input: &schema.OpenAIRequest{PredictionOptions: schema.PredictionOptions{BasicModelRequest: schema.BasicModelRequest{Model: "m"}}},
-				raw:   map[string]interface{}{"seconds": 3.0, "fps": 24.0},
-				expectsF: 24,
-				expectsN: 72,
-			},
-		}
-
-		for _, c := range cases {
-			By(c.name)
-			vr := openai.MapOpenAIToVideo(c.input, c.raw)
-			if c.expectsW != 0 {
-				Expect(vr.Width).To(Equal(c.expectsW))
-			}
-			if c.expectsH != 0 {
-				Expect(vr.Height).To(Equal(c.expectsH))
-			}
-			if c.expectsF != 0 {
-				Expect(vr.FPS).To(Equal(c.expectsF))
-			}
-			if c.expectsN != 0 {
-				Expect(vr.NumFrames).To(Equal(c.expectsN))
-			}
-
-			b, err := json.Marshal(vr)
-			Expect(err).ToNot(HaveOccurred())
-			_ = b
-		}
-	})
-})
-

core/http/openai_videos_test.go

@@ -1,168 +0,0 @@
-package http_test
-
-import (
-    "bytes"
-    "context"
-    "encoding/json"
-    "io"
-    "net/http"
-    "os"
-    "path/filepath"
-    "time"
-
-    "github.com/mudler/LocalAI/core/application"
-    "github.com/mudler/LocalAI/core/config"
-    "github.com/mudler/LocalAI/pkg/system"
-    "github.com/mudler/LocalAI/pkg/grpc"
-    pb "github.com/mudler/LocalAI/pkg/grpc/proto"
-    "fmt"
-    . "github.com/mudler/LocalAI/core/http"
-    "github.com/labstack/echo/v4"
-
-    . "github.com/onsi/ginkgo/v2"
-    . "github.com/onsi/gomega"
-)
-
-const testAPIKey = "joshua"
-
-type fakeAI struct{}
-
-func (f *fakeAI) Busy() bool                                { return false }
-func (f *fakeAI) Lock()                                     {}
-func (f *fakeAI) Unlock()                                   {}
-func (f *fakeAI) Locking() bool                             { return false }
-func (f *fakeAI) Predict(*pb.PredictOptions) (string, error) { return "", nil }
-func (f *fakeAI) PredictStream(*pb.PredictOptions, chan string) error {
-    return nil
-}
-func (f *fakeAI) Load(*pb.ModelOptions) error                        { return nil }
-func (f *fakeAI) Embeddings(*pb.PredictOptions) ([]float32, error)    { return nil, nil }
-func (f *fakeAI) GenerateImage(*pb.GenerateImageRequest) error       { return nil }
-func (f *fakeAI) GenerateVideo(*pb.GenerateVideoRequest) error       { return nil }
-func (f *fakeAI) Detect(*pb.DetectOptions) (pb.DetectResponse, error) { return pb.DetectResponse{}, nil }
-func (f *fakeAI) AudioTranscription(*pb.TranscriptRequest) (pb.TranscriptResult, error) {
-    return pb.TranscriptResult{}, nil
-}
-func (f *fakeAI) TTS(*pb.TTSRequest) error                          { return nil }
-func (f *fakeAI) SoundGeneration(*pb.SoundGenerationRequest) error  { return nil }
-func (f *fakeAI) TokenizeString(*pb.PredictOptions) (pb.TokenizationResponse, error) {
-    return pb.TokenizationResponse{}, nil
-}
-func (f *fakeAI) Status() (pb.StatusResponse, error) { return pb.StatusResponse{}, nil }
-func (f *fakeAI) StoresSet(*pb.StoresSetOptions) error        { return nil }
-func (f *fakeAI) StoresDelete(*pb.StoresDeleteOptions) error  { return nil }
-func (f *fakeAI) StoresGet(*pb.StoresGetOptions) (pb.StoresGetResult, error) {
-    return pb.StoresGetResult{}, nil
-}
-func (f *fakeAI) StoresFind(*pb.StoresFindOptions) (pb.StoresFindResult, error) {
-    return pb.StoresFindResult{}, nil
-}
-func (f *fakeAI) VAD(*pb.VADRequest) (pb.VADResponse, error) { return pb.VADResponse{}, nil }
-
-var _ = Describe("OpenAI /v1/videos (embedded backend)", func() {
-    var tmpdir string
-    var appServer *application.Application
-    var app *echo.Echo
-    var ctx context.Context
-    var cancel context.CancelFunc
-
-    BeforeEach(func() {
-        var err error
-        tmpdir, err = os.MkdirTemp("", "")
-        Expect(err).ToNot(HaveOccurred())
-
-        modelDir := filepath.Join(tmpdir, "models")
-        err = os.Mkdir(modelDir, 0750)
-        Expect(err).ToNot(HaveOccurred())
-
-        ctx, cancel = context.WithCancel(context.Background())
-
-        systemState, err := system.GetSystemState(
-            system.WithModelPath(modelDir),
-        )
-        Expect(err).ToNot(HaveOccurred())
-
-   		grpc.Provide("embedded://fake", &fakeAI{})
-
-        appServer, err = application.New(
-            config.WithContext(ctx),
-            config.WithSystemState(systemState),
-            config.WithApiKeys([]string{testAPIKey}),
-            config.WithGeneratedContentDir(tmpdir),
-            config.WithExternalBackend("fake", "embedded://fake"),
-        )
-        Expect(err).ToNot(HaveOccurred())
-    })
-
-    AfterEach(func() {
-        cancel()
-        if app != nil {
-            ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-            defer cancel()
-            _ = app.Shutdown(ctx)
-        }
-        _ = os.RemoveAll(tmpdir)
-    })
-
-    It("accepts OpenAI-style video create and delegates to backend", func() {
-		var err error
-		app, err = API(appServer)
-		Expect(err).ToNot(HaveOccurred())
-		go func() {
-			if err := app.Start("127.0.0.1:9091"); err != nil && err != http.ErrServerClosed {
-				// Log error if needed
-			}
-		}()
-
-        // wait for server
-        client := &http.Client{Timeout: 5 * time.Second}
-        Eventually(func() error {
-            req, _ := http.NewRequest("GET", "http://127.0.0.1:9091/v1/models", nil)
-            req.Header.Set("Authorization", "Bearer "+testAPIKey)
-            resp, err := client.Do(req)
-            if err != nil {
-                return err
-            }
-            defer resp.Body.Close()
-            if resp.StatusCode >= 400 {
-                return fmt.Errorf("bad status: %d", resp.StatusCode)
-            }
-            return nil
-        }, "30s", "500ms").Should(Succeed())
-
-        body := map[string]interface{}{
-            "model": "fake-model",
-            "backend": "fake",
-            "prompt": "a test video",
-            "size": "256x256",
-            "seconds": "1",
-        }
-        payload, err := json.Marshal(body)
-        Expect(err).ToNot(HaveOccurred())
-
-        req, err := http.NewRequest("POST", "http://127.0.0.1:9091/v1/videos", bytes.NewBuffer(payload))
-        Expect(err).ToNot(HaveOccurred())
-        req.Header.Set("Content-Type", "application/json")
-        req.Header.Set("Authorization", "Bearer "+testAPIKey)
-
-        resp, err := client.Do(req)
-        Expect(err).ToNot(HaveOccurred())
-        defer resp.Body.Close()
-        Expect(resp.StatusCode).To(Equal(200))
-
-        dat, err := io.ReadAll(resp.Body)
-        Expect(err).ToNot(HaveOccurred())
-
-        var out map[string]interface{}
-        err = json.Unmarshal(dat, &out)
-        Expect(err).ToNot(HaveOccurred())
-        data, ok := out["data"].([]interface{})
-        Expect(ok).To(BeTrue())
-        Expect(len(data)).To(BeNumerically(">", 0))
-        first := data[0].(map[string]interface{})
-        url, ok := first["url"].(string)
-        Expect(ok).To(BeTrue())
-        Expect(url).To(ContainSubstring("/generated-videos/"))
-        Expect(url).To(ContainSubstring(".mp4"))
-    })
-})

core/http/routes/openai.go

@@ -152,27 +152,6 @@ func RegisterOpenAIRoutes(app *echo.Echo,
 	app.POST("/v1/images/inpainting", inpaintingHandler, imageMiddleware...)
 	app.POST("/images/inpainting", inpaintingHandler, imageMiddleware...)
 
-	// videos (OpenAI-compatible endpoints mapped to LocalAI video handler)
-	videoHandler := openai.VideoEndpoint(application.ModelConfigLoader(), application.ModelLoader(), application.ApplicationConfig())
-	videoMiddleware := []echo.MiddlewareFunc{
-		traceMiddleware,
-		re.BuildFilteredFirstAvailableDefaultModel(config.BuildUsecaseFilterFn(config.FLAG_VIDEO)),
-		re.SetModelAndConfig(func() schema.LocalAIRequest { return new(schema.OpenAIRequest) }),
-		func(next echo.HandlerFunc) echo.HandlerFunc {
-			return func(c echo.Context) error {
-				if err := re.SetOpenAIRequest(c); err != nil {
-					return err
-				}
-				return next(c)
-			}
-		},
-	}
-
-	// OpenAI-style create video endpoint
-	app.POST("/v1/videos", videoHandler, videoMiddleware...)
-	app.POST("/v1/videos/generations", videoHandler, videoMiddleware...)
-	app.POST("/videos", videoHandler, videoMiddleware...)
-
 	// List models
 	app.GET("/v1/models", openai.ListModelsEndpoint(application.ModelConfigLoader(), application.ModelLoader(), application.ApplicationConfig()))
 	app.GET("/models", openai.ListModelsEndpoint(application.ModelConfigLoader(), application.ModelLoader(), application.ApplicationConfig()))

core/http/static/video.js

@@ -135,9 +135,9 @@ async function promptVideo() {
     return;
   }
 
-  // Make API request
+  // Make API request to LocalAI endpoint
   try {
-    const response = await fetch("v1/videos/generations", {
+    const response = await fetch("video", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -219,9 +219,13 @@ async function promptVideo() {
         `;
         captionDiv.appendChild(detailsDiv);
 
+        // Button container
+        const buttonContainer = document.createElement("div");
+        buttonContainer.className = "mt-1.5 flex gap-2";
+
         // Copy prompt button
         const copyBtn = document.createElement("button");
-        copyBtn.className = "mt-1.5 px-2 py-0.5 text-[10px] bg-[var(--color-primary)] text-white rounded hover:opacity-80";
+        copyBtn.className = "px-2 py-0.5 text-[10px] bg-[var(--color-primary)] text-white rounded hover:opacity-80";
         copyBtn.innerHTML = '<i class="fas fa-copy mr-1"></i>Copy Prompt';
         copyBtn.onclick = () => {
           navigator.clipboard.writeText(prompt).then(() => {
@@ -231,7 +235,18 @@ async function promptVideo() {
             }, 2000);
           });
         };
-        captionDiv.appendChild(copyBtn);
+        buttonContainer.appendChild(copyBtn);
+
+        // Download video button
+        const downloadBtn = document.createElement("button");
+        downloadBtn.className = "px-2 py-0.5 text-[10px] bg-[var(--color-primary)] text-white rounded hover:opacity-80";
+        downloadBtn.innerHTML = '<i class="fas fa-download mr-1"></i>Download Video';
+        downloadBtn.onclick = () => {
+          downloadVideo(item, downloadBtn);
+        };
+        buttonContainer.appendChild(downloadBtn);
+
+        captionDiv.appendChild(buttonContainer);
 
         videoContainer.appendChild(captionDiv);
         resultDiv.appendChild(videoContainer);
@@ -269,6 +284,67 @@ function escapeHtml(text) {
   return div.innerHTML;
 }
 
+// Helper function to download video
+function downloadVideo(item, button) {
+  try {
+    let videoUrl;
+    let filename = "generated-video.mp4";
+
+    if (item.url) {
+      // If we have a URL, use it directly
+      videoUrl = item.url;
+      // Extract filename from URL if possible
+      const urlParts = item.url.split("/");
+      if (urlParts.length > 0) {
+        const lastPart = urlParts[urlParts.length - 1];
+        if (lastPart && lastPart.includes(".")) {
+          filename = lastPart;
+        }
+      }
+    } else if (item.b64_json) {
+      // Convert base64 to blob
+      const byteCharacters = atob(item.b64_json);
+      const byteNumbers = new Array(byteCharacters.length);
+      for (let i = 0; i < byteCharacters.length; i++) {
+        byteNumbers[i] = byteCharacters.charCodeAt(i);
+      }
+      const byteArray = new Uint8Array(byteNumbers);
+      const blob = new Blob([byteArray], { type: "video/mp4" });
+      videoUrl = URL.createObjectURL(blob);
+    } else {
+      console.error("No video data available for download");
+      return;
+    }
+
+    // Create a temporary anchor element to trigger download
+    const link = document.createElement("a");
+    link.href = videoUrl;
+    link.download = filename;
+    link.style.display = "none";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+
+    // Clean up object URL if we created one
+    if (item.b64_json && videoUrl.startsWith("blob:")) {
+      setTimeout(() => URL.revokeObjectURL(videoUrl), 100);
+    }
+
+    // Show feedback
+    const originalHTML = button.innerHTML;
+    button.innerHTML = '<i class="fas fa-check mr-1"></i>Downloaded!';
+    setTimeout(() => {
+      button.innerHTML = originalHTML;
+    }, 2000);
+  } catch (error) {
+    console.error("Error downloading video:", error);
+    button.innerHTML = '<i class="fas fa-exclamation-triangle mr-1"></i>Error';
+    setTimeout(() => {
+      button.innerHTML = '<i class="fas fa-download mr-1"></i>Download Video';
+    }, 2000);
+  }
+}
+
 // Initialize
 document.addEventListener("DOMContentLoaded", function() {
   const input = document.getElementById("input");

core/schema/openresponses.go

@@ -93,7 +93,12 @@ type ORItemParam struct {
 	// Function call output fields
 	Output interface{} `json:"output,omitempty"` // string or []ORContentPart
 
+	// Reasoning fields (for type == "reasoning")
+	Summary         []ORContentPart `json:"summary,omitempty"`          // Array of summary parts
+	EncryptedContent *string        `json:"encrypted_content,omitempty"` // Provider-specific encrypted content
+
 	// Note: For item_reference type, use the ID field above to reference the item
+	// Note: For reasoning type, Content field (from message fields) contains the raw reasoning content
 }
 
 // ORContentPart represents a content block (discriminated union by type)

docs/content/advanced/model-configuration.md

@@ -397,6 +397,83 @@ Agent/autonomous agent configuration:
 | `agent.enable_mcp_prompts` | bool | Enable MCP prompts |
 | `agent.enable_plan_re_evaluator` | bool | Enable plan re-evaluation |
 
+## Reasoning Configuration
+
+Configure how reasoning tags are extracted and processed from model output. Reasoning tags are used by models like DeepSeek, Command-R, and others to include internal reasoning steps in their responses.
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `reasoning.disable` | bool | `false` | When `true`, disables reasoning extraction entirely. The original content is returned without any processing. |
+| `reasoning.disable_reasoning_tag_prefill` | bool | `false` | When `true`, disables automatic prepending of thinking start tokens. Use this when your model already includes reasoning tags in its output format. |
+| `reasoning.strip_reasoning_only` | bool | `false` | When `true`, extracts and removes reasoning tags from content but discards the reasoning text. Useful when you want to clean reasoning tags from output without storing the reasoning content. |
+| `reasoning.thinking_start_tokens` | array | `[]` | List of custom thinking start tokens to detect in prompts. Custom tokens are checked before default tokens. |
+| `reasoning.tag_pairs` | array | `[]` | List of custom tag pairs for reasoning extraction. Each entry has `start` and `end` fields. Custom pairs are checked before default pairs. |
+
+### Reasoning Tag Formats
+
+The reasoning extraction supports multiple tag formats used by different models:
+
+- `<thinking>...</thinking>` - General thinking tag
+- `<think>...</think>` - DeepSeek, Granite, ExaOne, GLM models
+- `<|START_THINKING|>...<|END_THINKING|>` - Command-R models
+- `<|inner_prefix|>...<|inner_suffix|>` - Apertus models
+- `<seed:think>...</seed:think>` - Seed models
+- `<|think|>...<|end|><|begin|>assistant<|content|>` - Solar Open models
+- `[THINK]...[/THINK]` - Magistral models
+
+### Examples
+
+**Disable reasoning extraction:**
+```yaml
+reasoning:
+  disable: true
+```
+
+**Extract reasoning but don't prepend tags:**
+```yaml
+reasoning:
+  disable_reasoning_tag_prefill: true
+```
+
+**Strip reasoning tags without storing reasoning content:**
+```yaml
+reasoning:
+  strip_reasoning_only: true
+```
+
+**Complete example with reasoning configuration:**
+```yaml
+name: deepseek-model
+backend: llama-cpp
+parameters:
+  model: deepseek.gguf
+
+reasoning:
+  disable: false
+  disable_reasoning_tag_prefill: false
+  strip_reasoning_only: false
+```
+
+**Example with custom tokens and tag pairs:**
+```yaml
+name: custom-reasoning-model
+backend: llama-cpp
+parameters:
+  model: custom.gguf
+
+reasoning:
+  thinking_start_tokens:
+    - "<custom:think>"
+    - "<my:reasoning>"
+  tag_pairs:
+    - start: "<custom:think>"
+      end: "</custom:think>"
+    - start: "<my:reasoning>"
+      end: "</my:reasoning>"
+```
+
+**Note:** Custom tokens and tag pairs are checked before the default ones, giving them priority. This allows you to override default behavior or add support for new reasoning tag formats.
+
 ## Pipeline Configuration
 
 Define pipelines for audio-to-audio processing:

docs/content/features/text-to-audio.md

@@ -215,50 +215,90 @@ curl http://localhost:8080/tts -H "Content-Type: application/json" -d '{
    }' | aplay
 ```
 
-### Vall-E-X
+### Qwen3-TTS
 
-[VALL-E-X](https://github.com/Plachtaa/VALL-E-X) is an open source implementation of Microsoft's VALL-E X zero-shot TTS model.
+[Qwen3-TTS](https://github.com/QwenLM/Qwen3-TTS) is a high-quality text-to-speech model that supports three modes: custom voice (predefined speakers), voice design (natural language instructions), and voice cloning (from reference audio).
 
 #### Setup
 
-The backend will automatically download the required files in order to run the model.
-
-This is an extra backend - in the container is already available and there is nothing to do for the setup. If you are building manually, you need to install Vall-E-X manually first.
+Install the `qwen-tts` model in the Model gallery or run `local-ai run models install qwen-tts`.
 
 #### Usage
 
-Use the tts endpoint by specifying the vall-e-x backend:
+Use the tts endpoint by specifying the qwen-tts backend:
 
 ```
 curl http://localhost:8080/tts -H "Content-Type: application/json" -d '{         
-     "backend": "vall-e-x",
-     "input":"Hello!"
+     "model": "qwen-tts",
+     "input":"Hello world, this is a test."
    }' | aplay
 ```
 
-#### Voice cloning
+#### Custom Voice Mode
 
-In order to use voice cloning capabilities you must create a `YAML` configuration file to setup a model:
+Qwen3-TTS supports predefined speakers. You can specify a speaker using the `voice` parameter:
 
 ```yaml
-name: cloned-voice
-backend: vall-e-x
+name: qwen-tts
+backend: qwen-tts
 parameters:
-  model: "cloned-voice"
+  model: Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice
 tts:
-    vall-e:
-      # The path to the audio file to be cloned
-      # relative to the models directory
-      # Max 15s
-      audio_path: "audio-sample.wav"
+  voice: "Vivian"  # Available speakers: Vivian, Serena, Uncle_Fu, Dylan, Eric, Ryan, Aiden, Ono_Anna, Sohee
 ```
 
-Then you can specify the model name in the requests:
+Available speakers:
+- **Chinese**: Vivian, Serena, Uncle_Fu, Dylan, Eric
+- **English**: Ryan, Aiden
+- **Japanese**: Ono_Anna
+- **Korean**: Sohee
+
+#### Voice Design Mode
+
+Voice Design allows you to create custom voices using natural language instructions. Configure the model with an `instruct` option:
+
+```yaml
+name: qwen-tts-design
+backend: qwen-tts
+parameters:
+  model: Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign
+options:
+  - "instruct:体现撒娇稚嫩的萝莉女声，音调偏高且起伏明显，营造出黏人、做作又刻意卖萌的听觉效果。"
+```
+
+Then use the model:
 
 ```
 curl http://localhost:8080/tts -H "Content-Type: application/json" -d '{         
-     "model": "cloned-voice",
-     "input":"Hello!"
+     "model": "qwen-tts-design",
+     "input":"Hello world, this is a test."
+   }' | aplay
+```
+
+#### Voice Clone Mode
+
+Voice Clone allows you to clone a voice from reference audio. Configure the model with an `AudioPath` and optional `ref_text`:
+
+```yaml
+name: qwen-tts-clone
+backend: qwen-tts
+parameters:
+  model: Qwen/Qwen3-TTS-12Hz-1.7B-Base
+tts:
+  audio_path: "path/to/reference_audio.wav"  # Reference audio file
+options:
+  - "ref_text:This is the transcript of the reference audio."
+  - "x_vector_only_mode:false"  # Set to true to use only speaker embedding (ref_text not required)
+```
+
+You can also use URLs or base64 strings for the reference audio. The backend automatically detects the mode based on available parameters (AudioPath → VoiceClone, instruct option → VoiceDesign, voice parameter → CustomVoice).
+
+Then use the model:
+
+```
+curl http://localhost:8080/tts -H "Content-Type: application/json" -d '{         
+     "model": "qwen-tts-clone",
+     "input":"Hello world, this is a test."
    }' | aplay
 ```
 

gallery/index.yaml

@@ -1,4 +1,86 @@
 ---
+- name: "huihui-glm-4.7-flash-abliterated-i1"
+  url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
+  urls:
+    - https://huggingface.co/mradermacher/Huihui-GLM-4.7-Flash-abliterated-i1-GGUF
+  description: |
+    The model is a quantized version of **huihui-ai/Huihui-GLM-4.7-Flash-abliterated**, optimized for efficiency and deployment. It uses GGUF files with various quantization levels (e.g., IQ1_M, IQ2_XXS, Q4_K_M) and is designed for tasks requiring low-resource deployment. Key features include:
+      - **Base Model**: Huihui-GLM-4.7-Flash-abliterated (unmodified, original model).
+      - **Quantization**: Supports IQ1_M to Q4_K_M, balancing accuracy and efficiency.
+      - **Use Cases**: Suitable for applications needing lightweight inference, such as edge devices or resource-constrained environments.
+      - **Downloads**: Available in GGUF format with varying quality and size (e.g., 0.2GB to 18.2GB).
+      - **Tags**: Abliterated, uncensored, and optimized for specific tasks.
+
+    This model is a modified version of the original GLM-4.7, tailored for deployment with quantized weights.
+  overrides:
+    parameters:
+      model: llama-cpp/models/Huihui-GLM-4.7-Flash-abliterated.i1-Q4_K_M.gguf
+    name: Huihui-GLM-4.7-Flash-abliterated-i1-GGUF
+    backend: llama-cpp
+    template:
+      use_tokenizer_template: true
+    known_usecases:
+      - chat
+    function:
+      grammar:
+        disable: true
+    description: Imported from https://huggingface.co/mradermacher/Huihui-GLM-4.7-Flash-abliterated-i1-GGUF
+    options:
+      - use_jinja:true
+  files:
+    - filename: llama-cpp/models/Huihui-GLM-4.7-Flash-abliterated.i1-Q4_K_M.gguf
+      sha256: 2ec5fcf2aa882c0c55fc67a35ea7ed50c24016bc4a8a4ceacfcea103dc2f1cb8
+      uri: https://huggingface.co/mradermacher/Huihui-GLM-4.7-Flash-abliterated-i1-GGUF/resolve/main/Huihui-GLM-4.7-Flash-abliterated.i1-Q4_K_M.gguf
+- name: "mox-small-1-i1"
+  url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
+  urls:
+    - https://huggingface.co/mradermacher/mox-small-1-i1-GGUF
+  description: |
+    The model, **vanta-research/mox-small-1**, is a small-scale text-generation model optimized for conversational AI tasks. It supports chat, persona research, and chatbot applications. The quantized versions (e.g., i1-Q4_K_M, i1-Q4_K_S) are available for efficient deployment, with the i1-Q4_K_S variant offering the best balance of size, speed, and quality. The model is designed for lightweight inference and is compatible with frameworks like HuggingFace Transformers.
+  overrides:
+    parameters:
+      model: llama-cpp/models/mox-small-1.i1-Q4_K_M.gguf
+    name: mox-small-1-i1-GGUF
+    backend: llama-cpp
+    template:
+      use_tokenizer_template: true
+    known_usecases:
+      - chat
+    function:
+      grammar:
+        disable: true
+    description: Imported from https://huggingface.co/mradermacher/mox-small-1-i1-GGUF
+    options:
+      - use_jinja:true
+  files:
+    - filename: llama-cpp/models/mox-small-1.i1-Q4_K_M.gguf
+      sha256: f25e9612e985adf01869f412f997a7aaace65e1ee0c97d4975070febdcbbb978
+      uri: https://huggingface.co/mradermacher/mox-small-1-i1-GGUF/resolve/main/mox-small-1.i1-Q4_K_M.gguf
+- name: "glm-4.7-flash"
+  url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
+  urls:
+    - https://huggingface.co/unsloth/GLM-4.7-Flash-GGUF
+  description: |
+    **GLM-4.7-Flash** is a 30B-A3B MoE (Model Organism Ensemble) model designed for efficient deployment. It outperforms competitors in benchmarks like AIME 25, GPQA, and τ²-Bench, offering strong accuracy while balancing performance and efficiency. Optimized for lightweight use cases, it supports inference via frameworks like vLLM and SGLang, with detailed deployment instructions in the official repository. Ideal for applications requiring high-quality text generation with minimal resource consumption.
+  overrides:
+    parameters:
+      model: llama-cpp/models/GLM-4.7-Flash-Q4_K_M.gguf
+    name: GLM-4.7-Flash-GGUF
+    backend: llama-cpp
+    template:
+      use_tokenizer_template: true
+    known_usecases:
+      - chat
+    function:
+      grammar:
+        disable: true
+    description: Imported from https://huggingface.co/unsloth/GLM-4.7-Flash-GGUF
+    options:
+      - use_jinja:true
+  files:
+    - filename: llama-cpp/models/GLM-4.7-Flash-Q4_K_M.gguf
+      uri: https://huggingface.co/unsloth/GLM-4.7-Flash-GGUF/resolve/main/GLM-4.7-Flash-Q4_K_M.gguf
+      sha256: 73ba18480e06ccda453a26263c0e2be2bd86294e827b1812ddea2f88bba2d924
 - name: "qwen3-vl-reranker-8b"
   url: "github:mudler/LocalAI/gallery/virtual.yaml@master"
   urls:
@@ -13096,6 +13178,96 @@
     - filename: t5xxl_fp16.safetensors
       sha256: 6e480b09fae049a72d2a8c5fbccb8d3e92febeb233bbe9dfe7256958a9167635
       uri: https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors
+- !!merge <<: *flux
+  name: flux.2-dev
+  url: "github:mudler/LocalAI/gallery/flux-ggml.yaml@master"
+  description: |
+    FLUX.2 [dev] is a 32 billion parameter rectified flow transformer capable of generating, editing and combining images based on text instructions.
+  urls:
+    - https://huggingface.co/black-forest-labs/FLUX.2-dev
+  overrides:
+    step: 50
+    options:
+      - "diffusion_model"
+      - "vae_path:stablediffusion-cpp/models/flux2-vae.safetensors"
+      - "sampler:euler"
+      - llm_path:stablediffusion-cpp/models/Mistral-Small-3.2-24B-Instruct-2506-Q4_K_M.gguf
+      - offload_params_to_cpu:true
+    cfg_scale: 1
+    parameters:
+      model: stablediffusion-cpp/models/flux2-dev-Q4_K_M.gguf
+  files:
+    - filename: "stablediffusion-cpp/models/flux2-dev-Q4_K_M.gguf"
+      sha256: "fca680c7b221a713b5cf7db6cf6b33474875320ee61f4c585bc33fe391dab9a6"
+      uri: "https://huggingface.co/city96/FLUX.2-dev-gguf/resolve/main/flux2-dev-Q4_K_M.gguf"
+    - filename: stablediffusion-cpp/models/flux2-vae.safetensors
+      sha256: d64f3a68e1cc4f9f4e29b6e0da38a0204fe9a49f2d4053f0ec1fa1ca02f9c4b5
+      uri: https://huggingface.co/Comfy-Org/flux2-dev/resolve/main/split_files/vae/flux2-vae.safetensors
+    - filename: stablediffusion-cpp/models/Mistral-Small-3.2-24B-Instruct-2506-Q4_K_M.gguf
+      sha256: a3cc56310807ed0d145eaf9f018ccda9ae7ad8edb41ec870aa2454b0d4700b3c
+      uri: https://huggingface.co/unsloth/Mistral-Small-3.2-24B-Instruct-2506-GGUF/resolve/main/Mistral-Small-3.2-24B-Instruct-2506-Q4_K_M.gguf
+- !!merge <<: *flux
+  name: flux.2-klein-4b
+  url: "github:mudler/LocalAI/gallery/flux-ggml.yaml@master"
+  license: apache-2.0
+  description: |
+    The FLUX.2 [klein] model family are our fastest image models to date. FLUX.2 [klein] unifies generation and editing in a single compact architecture, delivering state-of-the-art quality with end-to-end inference in as low as under a second. Built for applications that require real-time image generation without sacrificing quality, and runs on consumer hardware, with as little as 13GB VRAM.
+
+    FLUX.2 [klein] 4B is a 4 billion parameter rectified flow transformer capable of generating images from text descriptions and supports multi-reference editing capabilities.
+  urls:
+    - https://huggingface.co/black-forest-labs/FLUX.2-klein-4B
+  overrides:
+    step: 4
+    options:
+      - "diffusion_model"
+      - "vae_path:stablediffusion-cpp/models/flux2-vae.safetensors"
+      - "sampler:euler"
+      - llm_path:stablediffusion-cpp/models/Qwen3-4B-Q4_K_M.gguf
+      - offload_params_to_cpu:true
+    cfg_scale: 1
+    parameters:
+      model: stablediffusion-cpp/models/flux-2-klein-4b-Q4_0.gguf
+  files:
+    - filename: "stablediffusion-cpp/models/flux-2-klein-4b-Q4_0.gguf"
+      sha256: "d1023499ef3f2f82ff7c50e6778495195c1b6cc34835741778868428111f9ff4"
+      uri: "https://huggingface.co/leejet/FLUX.2-klein-4B-GGUF/resolve/main/flux-2-klein-4b-Q4_0.gguf"
+    - filename: stablediffusion-cpp/models/flux2-vae.safetensors
+      sha256: d64f3a68e1cc4f9f4e29b6e0da38a0204fe9a49f2d4053f0ec1fa1ca02f9c4b5
+      uri: https://huggingface.co/Comfy-Org/flux2-dev/resolve/main/split_files/vae/flux2-vae.safetensors
+    - filename: stablediffusion-cpp/models/Qwen3-4B-Q4_K_M.gguf
+      sha256: f6f851777709861056efcdad3af01da38b31223a3ba26e61a4f8bf3a2195813a
+      uri: https://huggingface.co/unsloth/Qwen3-4B-GGUF/resolve/main/Qwen3-4B-Q4_K_M.gguf
+- !!merge <<: *flux
+  name: flux.2-klein-9b
+  url: "github:mudler/LocalAI/gallery/flux-ggml.yaml@master"
+  license: apache-2.0
+  description: |
+    The FLUX.2 [klein] model family are our fastest image models to date. FLUX.2 [klein] unifies generation and editing in a single compact architecture, delivering state-of-the-art quality with end-to-end inference in as low as under a second. Built for applications that require real-time image generation without sacrificing quality, and runs on consumer hardware, with as little as 13GB VRAM.
+
+    FLUX.2 [klein] 9B is a 9 billion parameter rectified flow transformer capable of generating images from text descriptions and supports multi-reference editing capabilities.
+  urls:
+    - https://huggingface.co/black-forest-labs/FLUX.2-klein-4B
+  overrides:
+    step: 4
+    options:
+      - "diffusion_model"
+      - "vae_path:stablediffusion-cpp/models/flux2-vae.safetensors"
+      - "sampler:euler"
+      - llm_path:stablediffusion-cpp/models/Qwen3-4B-Q4_K_M.gguf
+      - offload_params_to_cpu:true
+    cfg_scale: 1
+    parameters:
+      model: stablediffusion-cpp/models/flux-2-klein-9b-Q4_0.gguf
+  files:
+    - filename: "stablediffusion-cpp/models/flux-2-klein-9b-Q4_0.gguf"
+      sha256: "a7e77afa96871d16679ff7b949bd25f20c8179f219c4b662cac91e81ed99b944"
+      uri: "https://huggingface.co/leejet/FLUX.2-klein-9B-GGUF/resolve/main/flux-2-klein-9b-Q4_0.gguf"
+    - filename: stablediffusion-cpp/models/flux2-vae.safetensors
+      sha256: d64f3a68e1cc4f9f4e29b6e0da38a0204fe9a49f2d4053f0ec1fa1ca02f9c4b5
+      uri: https://huggingface.co/Comfy-Org/flux2-dev/resolve/main/split_files/vae/flux2-vae.safetensors
+    - filename: stablediffusion-cpp/models/Qwen3-4B-Q4_K_M.gguf
+      sha256: f6f851777709861056efcdad3af01da38b31223a3ba26e61a4f8bf3a2195813a
+      uri: https://huggingface.co/unsloth/Qwen3-4B-GGUF/resolve/main/Qwen3-4B-Q4_K_M.gguf
 - &zimage
   name: Z-Image-Turbo
   icon: https://z-image.ai/logo.png

pkg/grpc/backend.go

@@ -57,4 +57,6 @@ type Backend interface {
 	GetTokenMetrics(ctx context.Context, in *pb.MetricsRequest, opts ...grpc.CallOption) (*pb.MetricsResponse, error)
 
 	VAD(ctx context.Context, in *pb.VADRequest, opts ...grpc.CallOption) (*pb.VADResponse, error)
+
+	ModelMetadata(ctx context.Context, in *pb.ModelOptions, opts ...grpc.CallOption) (*pb.ModelMetadataResponse, error)
 }

pkg/grpc/base/base.go

@@ -77,6 +77,10 @@ func (llm *Base) TokenizeString(opts *pb.PredictOptions) (pb.TokenizationRespons
 	return pb.TokenizationResponse{}, fmt.Errorf("unimplemented")
 }
 
+func (llm *Base) ModelMetadata(opts *pb.ModelOptions) (*pb.ModelMetadataResponse, error) {
+	return nil, fmt.Errorf("unimplemented")
+}
+
 // backends may wish to call this to capture the gopsutil info, then enhance with additional memory usage details?
 func (llm *Base) Status() (pb.StatusResponse, error) {
 	return pb.StatusResponse{

pkg/grpc/client.go

@@ -537,3 +537,25 @@ func (c *Client) Detect(ctx context.Context, in *pb.DetectOptions, opts ...grpc.
 	client := pb.NewBackendClient(conn)
 	return client.Detect(ctx, in, opts...)
 }
+
+func (c *Client) ModelMetadata(ctx context.Context, in *pb.ModelOptions, opts ...grpc.CallOption) (*pb.ModelMetadataResponse, error) {
+	if !c.parallel {
+		c.opMutex.Lock()
+		defer c.opMutex.Unlock()
+	}
+	c.setBusy(true)
+	defer c.setBusy(false)
+	c.wdMark()
+	defer c.wdUnMark()
+	conn, err := grpc.Dial(c.address, grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithDefaultCallOptions(
+			grpc.MaxCallRecvMsgSize(50*1024*1024), // 50MB
+			grpc.MaxCallSendMsgSize(50*1024*1024), // 50MB
+		))
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+	client := pb.NewBackendClient(conn)
+	return client.ModelMetadata(ctx, in, opts...)
+}

pkg/grpc/embed.go

@@ -99,6 +99,10 @@ func (e *embedBackend) VAD(ctx context.Context, in *pb.VADRequest, opts ...grpc.
 	return e.s.VAD(ctx, in)
 }
 
+func (e *embedBackend) ModelMetadata(ctx context.Context, in *pb.ModelOptions, opts ...grpc.CallOption) (*pb.ModelMetadataResponse, error) {
+	return e.s.ModelMetadata(ctx, in)
+}
+
 func (e *embedBackend) GetTokenMetrics(ctx context.Context, in *pb.MetricsRequest, opts ...grpc.CallOption) (*pb.MetricsResponse, error) {
 	return e.s.GetMetrics(ctx, in)
 }

pkg/grpc/interface.go

@@ -28,6 +28,8 @@ type AIModel interface {
 	StoresFind(*pb.StoresFindOptions) (pb.StoresFindResult, error)
 
 	VAD(*pb.VADRequest) (pb.VADResponse, error)
+
+	ModelMetadata(*pb.ModelOptions) (*pb.ModelMetadataResponse, error)
 }
 
 func newReply(s string) *pb.Reply {

pkg/grpc/server.go

@@ -263,6 +263,18 @@ func (s *server) VAD(ctx context.Context, in *pb.VADRequest) (*pb.VADResponse, e
 	return &res, nil
 }
 
+func (s *server) ModelMetadata(ctx context.Context, in *pb.ModelOptions) (*pb.ModelMetadataResponse, error) {
+	if s.llm.Locking() {
+		s.llm.Lock()
+		defer s.llm.Unlock()
+	}
+	res, err := s.llm.ModelMetadata(in)
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
 func StartServer(address string, model AIModel) error {
 	lis, err := net.Listen("tcp", address)
 	if err != nil {

pkg/model/watchdog.go

@@ -393,7 +393,7 @@ func (wd *WatchDog) checkMemory() {
 		memoryType = "RAM"
 	}
 
-	xlog.Debug("[WatchDog] Memory check", "type", memoryType, "usage_percent", aggregate.UsagePercent, "threshold_percent", thresholdPercent, "loaded_models", modelCount)
+	//xlog.Debug("[WatchDog] Memory check", "type", memoryType, "usage_percent", aggregate.UsagePercent, "threshold_percent", thresholdPercent, "loaded_models", modelCount)
 
 	// Check if usage exceeds threshold
 	if aggregate.UsagePercent > thresholdPercent {

pkg/reasoning/config.go

@@ -1,8 +1,15 @@
 package reasoning
 
-type ReasoningConfig struct {
-	// ThinkingForcedOpen indicates that the model outputs reasoning without an opening tag.
-	// When true, all content from the start is treated as reasoning until a closing tag is found.
-	// This is useful for models like GLM-4 that output reasoning without <think> but end with </think>.
-	ThinkingForcedOpen bool `yaml:"thinking_forced_open,omitempty" json:"thinking_forced_open,omitempty"`
+// TagPair represents a start/end tag pair for reasoning extraction
+type TagPair struct {
+	Start string `yaml:"start" json:"start"`
+	End   string `yaml:"end" json:"end"`
+}
+
+type Config struct {
+	DisableReasoningTagPrefill *bool     `yaml:"disable_reasoning_tag_prefill,omitempty" json:"disable_reasoning_tag_prefill,omitempty"`
+	DisableReasoning           *bool     `yaml:"disable,omitempty" json:"disable,omitempty"`
+	StripReasoningOnly         *bool     `yaml:"strip_reasoning_only,omitempty" json:"strip_reasoning_only,omitempty"`
+	ThinkingStartTokens        []string  `yaml:"thinking_start_tokens,omitempty" json:"thinking_start_tokens,omitempty"`
+	TagPairs                   []TagPair `yaml:"tag_pairs,omitempty" json:"tag_pairs,omitempty"`
 }

pkg/reasoning/options.go

@@ -1,18 +0,0 @@
-package reasoning
-
-// options holds the configuration for reasoning extraction
-type options struct {
-	thinkingForcedOpen bool
-}
-
-// Option is a functional option for configuring reasoning extraction
-type Option func(*options)
-
-// WithThinkingForcedOpen configures the extractor to treat all content from the start
-// as reasoning until a closing tag is found. This is useful for models like GLM-4
-// that output reasoning without <think> but end with </think>.
-func WithThinkingForcedOpen() Option {
-	return func(o *options) {
-		o.thinkingForcedOpen = true
-	}
-}

pkg/reasoning/reasoning.go

@@ -4,118 +4,130 @@ import (
 	"strings"
 )
 
-// Common thinking/reasoning opening tags used by various models.
-// These match the tags detected by llama.cpp in common/chat.cpp
-var thinkingOpenTags = []string{
-	// DeepSeek R1, V3.1, Nemotron V2, MiniMax M2, Hermes 2 Pro, Granite, Exaone MOE
-	"<think>\n",
-	"<think>",
-	// Generic thinking tags
-	"<thinking>\n",
-	"<thinking>",
-	// Apertus
-	"<|inner_prefix|>",
-	// Command R7B
-	"<|START_THINKING|>",
-	// Seed
-	"<seed:think>",
-	// Magistral (not in llama.cpp but common)
-	"[THINK]\n",
-	"[THINK]",
-}
-
-// DetectThinkingForcedOpen checks if a prompt ends with a thinking opening tag.
-// This is used to automatically detect when the model template has already added
-// the opening thinking tag, meaning the model will output reasoning content directly.
-// Returns true if the prompt ends with a known thinking opening tag.
-func DetectThinkingForcedOpen(prompt string) bool {
-	for _, tag := range thinkingOpenTags {
-		if strings.HasSuffix(prompt, tag) {
-			return true
-		}
-	}
-	return false
-}
-
-// Extract extracts reasoning content from thinking tags and returns
-// both the extracted reasoning and the cleaned content (with tags removed).
-// It handles <thinking>...</thinking> and <think>...</think> tags.
-// Multiple reasoning blocks are concatenated with newlines.
-// It also handles the case where only a closing tag is present (no opening tag),
-// in which case everything before the closing tag is treated as reasoning.
-//
-// Use WithThinkingForcedOpen() option when all content from the start should be
-// treated as reasoning until a closing tag is found.
-func Extract(content string, opts ...Option) (reasoning string, cleanedContent string) {
-	if content == "" {
-		return "", content
+// DetectThinkingStartToken checks if the prompt or template contains a thinking start token
+// and returns the detected token. This indicates that the model's prompt template
+// already includes the thinking token, so the model output will start with reasoning
+// content without an explicit opening tag.
+// Returns the detected token if found, empty string otherwise.
+// Common tokens checked (in order of specificity - longer first):
+// Based on llama.cpp's chat-parser.cpp implementations:
+// - <|START_THINKING|>      (Command-R models)
+// - <|inner_prefix|>        (Apertus models)
+// - <seed:think>            (Seed models)
+// - <think>    (DeepSeek, Granite, ExaOne models)
+// - <|think|>               (Solar Open models)
+// - <thinking>              (General thinking tag)
+// - [THINK]                 (Magistral models)
+// Custom tokens from config are checked first, then default tokens.
+func DetectThinkingStartToken(prompt string, config *Config) string {
+	// Common thinking start tokens (in order of specificity - longer first)
+	// Based on llama.cpp's chat-parser.cpp implementations
+	defaultTokens := []string{
+		"<|START_THINKING|>", // Command-R models
+		"<|inner_prefix|>",   // Apertus models
+		"<seed:think>",       // Seed models
+		"<think>",            // DeepSeek, Granite, ExaOne models
+		"<|think|>",          // Solar Open models
+		"<thinking>",         // General thinking tag
+		"[THINK]",            // Magistral models
 	}
 
-	cfg := &options{}
-	for _, opt := range opts {
-		opt(cfg)
+	// Merge custom tokens with default tokens (custom tokens first for priority)
+	var thinkingStartTokens []string
+	if config != nil && len(config.ThinkingStartTokens) > 0 {
+		thinkingStartTokens = append(thinkingStartTokens, config.ThinkingStartTokens...)
 	}
+	thinkingStartTokens = append(thinkingStartTokens, defaultTokens...)
 
-	if cfg.thinkingForcedOpen {
-		return extractForcedOpen(content)
-	}
-
-	return extractFromTags(content)
-}
-
-// extractForcedOpen handles the case where reasoning starts without an opening tag.
-// All content from the start is treated as reasoning until a closing tag is found.
-func extractForcedOpen(content string) (reasoning string, cleanedContent string) {
-	// Look for the earliest closing tag
-	// These match the closing tags used by llama.cpp for various models
-	closingTags := []string{
-		"</thinking>",
-		"</think>",
-		"<|END_THINKING|>", // Command R7B
-		"<|inner_suffix|>", // Apertus
-		"</seed:think>",    // Seed
-		"[/THINK]",         // Magistral
-	}
-
-	earliestCloseIdx := -1
-	var matchedCloseTag string
-
-	for _, closeTag := range closingTags {
-		idx := strings.Index(content, closeTag)
-		if idx != -1 && (earliestCloseIdx == -1 || idx < earliestCloseIdx) {
-			earliestCloseIdx = idx
-			matchedCloseTag = closeTag
+	// Check if prompt ends with any of these tokens (allowing for trailing whitespace/newlines)
+	trimmedPrompt := strings.TrimRight(prompt, " \t\n\r")
+	for _, token := range thinkingStartTokens {
+		if strings.Contains(trimmedPrompt, token) {
+			return token
 		}
 	}
 
-	if earliestCloseIdx == -1 {
-		// No closing tag found - all content is reasoning (still streaming)
-		return strings.TrimSpace(content), ""
-	}
-
-	// Found closing tag - everything before is reasoning, everything after is content
-	reasoning = strings.TrimSpace(content[:earliestCloseIdx])
-	cleanedContent = content[earliestCloseIdx+len(matchedCloseTag):]
-
-	// Continue processing the rest for any additional reasoning blocks
-	if cleanedContent != "" {
-		additionalReasoning, finalContent := extractFromTags(cleanedContent)
-		if additionalReasoning != "" {
-			if reasoning != "" {
-				reasoning = reasoning + "\n\n" + additionalReasoning
-			} else {
-				reasoning = additionalReasoning
+	// Also check if any of these tokens appear near the end (within last 100 chars)
+	// This handles cases where there might be stop tokens or other content after
+	if len(trimmedPrompt) > 100 {
+		lastPart := trimmedPrompt[len(trimmedPrompt)-100:]
+		for _, token := range thinkingStartTokens {
+			if idx := strings.LastIndex(lastPart, token); idx != -1 {
+				// Check if this is the last meaningful content (only whitespace after)
+				afterToken := lastPart[idx+len(token):]
+				if strings.TrimSpace(afterToken) == "" {
+					return token
+				}
 			}
 		}
-		cleanedContent = finalContent
+	}
+
+	return ""
+}
+
+// ExtractReasoningWithConfig extracts reasoning from content with the given config.
+// If reasoning is disabled, it returns the original content.
+// If thinking start token prefill is enabled, it prepends the thinking start token to the content.
+// It returns the extracted reasoning and the cleaned content.
+func ExtractReasoningWithConfig(content, thinkingStartToken string, config Config) (reasoning string, cleanedContent string) {
+	cleanedContent = content
+	// If reasoning is not disabled, prepend the thinking start token if needed and extract reasoning
+	if config.DisableReasoning == nil || !*config.DisableReasoning {
+		// If thinking start token prefill is not disabled, prepend the thinking start token
+		if config.DisableReasoningTagPrefill == nil || !*config.DisableReasoningTagPrefill {
+			cleanedContent = PrependThinkingTokenIfNeeded(cleanedContent, thinkingStartToken)
+		}
+		// Extract reasoning from the cleaned content
+		reasoning, cleanedContent = ExtractReasoning(cleanedContent, &config)
+		if config.StripReasoningOnly != nil && *config.StripReasoningOnly {
+			reasoning = ""
+		}
 	}
 
 	return reasoning, cleanedContent
 }
 
-// extractFromTags extracts reasoning content from thinking tags.
-// This is the core implementation that handles standard tag-based extraction.
-func extractFromTags(content string) (reasoning string, cleanedContent string) {
+// PrependThinkingTokenIfNeeded prepends the thinking start token to content if it was
+// detected in the prompt. This allows the standard extraction logic to work correctly
+// for models where the thinking token is already in the prompt.
+func PrependThinkingTokenIfNeeded(content string, startToken string) string {
+	if startToken == "" {
+		return content
+	}
+
+	// Check if content already starts with the token (allowing for leading whitespace)
+	trimmed := strings.TrimLeftFunc(content, func(r rune) bool {
+		return r == ' ' || r == '\t' || r == '\n' || r == '\r'
+	})
+
+	// If content already starts with the token, don't prepend
+	if strings.Contains(trimmed, startToken) {
+		return content
+	}
+
+	// Find where leading whitespace ends
+	whitespaceEnd := 0
+	for whitespaceEnd < len(content) {
+		r := content[whitespaceEnd]
+		if r != ' ' && r != '\t' && r != '\n' && r != '\r' {
+			break
+		}
+		whitespaceEnd++
+	}
+
+	// Prepend the token after whitespace to make it look like normal tagged content
+	if whitespaceEnd > 0 {
+		return content[:whitespaceEnd] + startToken + content[whitespaceEnd:]
+	}
+	return startToken + content
+}
+
+// ExtractReasoning extracts reasoning content from thinking tags and returns
+// both the extracted reasoning and the cleaned content (with tags removed).
+// It handles <thinking>...</thinking> and <think>...</think> tags.
+// Multiple reasoning blocks are concatenated with newlines.
+// Custom tag pairs from config are checked first, then default tag pairs.
+func ExtractReasoning(content string, config *Config) (reasoning string, cleanedContent string) {
 	if content == "" {
 		return "", content
 	}
@@ -124,18 +136,38 @@ func extractFromTags(content string) (reasoning string, cleanedContent string) {
 	var cleanedParts []string
 	remaining := content
 
-	// Define tag pairs to look for
-	// These match the tags used by llama.cpp for various models
-	tagPairs := []struct {
+	// Define default tag pairs to look for (matching llama.cpp's chat-parser.cpp)
+	defaultTagPairs := []struct {
 		start string
 		end   string
 	}{
-		{"<thinking>", "</thinking>"},
-		{"<think>", "</think>"},
-		{"<|START_THINKING|>", "<|END_THINKING|>"}, // Command R7B
-		{"<|inner_prefix|>", "<|inner_suffix|>"},   // Apertus
-		{"<seed:think>", "</seed:think>"},          // Seed
-		{"[THINK]", "[/THINK]"},                    // Magistral
+		{"<|START_THINKING|>", "<|END_THINKING|>"},            // Command-R models
+		{"<|inner_prefix|>", "<|inner_suffix|>"},              // Apertus models
+		{"<seed:think>", "</seed:think>"},                     // Seed models
+		{"<think>", "</think>"},                               // DeepSeek, Granite, ExaOne models
+		{"<|think|>", "<|end|><|begin|>assistant<|content|>"}, // Solar Open models (complex end)
+		{"<thinking>", "</thinking>"},                         // General thinking tag
+		{"[THINK]", "[/THINK]"},                               // Magistral models
+	}
+
+	// Merge custom tag pairs with default tag pairs (custom pairs first for priority)
+	var tagPairs []struct {
+		start string
+		end   string
+	}
+	if config != nil && len(config.TagPairs) > 0 {
+		for _, pair := range config.TagPairs {
+			if pair.Start != "" && pair.End != "" {
+				tagPairs = append(tagPairs, struct {
+					start string
+					end   string
+				}{pair.Start, pair.End})
+			}
+		}
+	}
+	// Add default tag pairs
+	for _, pair := range defaultTagPairs {
+		tagPairs = append(tagPairs, pair)
 	}
 
 	// Track the last position we've processed
@@ -146,7 +178,6 @@ func extractFromTags(content string) (reasoning string, cleanedContent string) {
 		earliestStart := -1
 		earliestEnd := -1
 		isUnclosed := false
-		isClosingOnly := false
 		var matchedTag struct {
 			start string
 			end   string
@@ -154,48 +185,30 @@ func extractFromTags(content string) (reasoning string, cleanedContent string) {
 
 		for _, tagPair := range tagPairs {
 			startIdx := strings.Index(remaining[lastPos:], tagPair.start)
-			endIdx := strings.Index(remaining[lastPos:], tagPair.end)
-
-			// Check for closing-only tag (closing tag appears before or without opening tag)
-			if endIdx != -1 && (startIdx == -1 || endIdx < startIdx) {
-				// Found a closing tag without a preceding opening tag
-				closingTagPos := endIdx + lastPos
-				if earliestStart == -1 || closingTagPos < earliestStart || (isClosingOnly && closingTagPos < earliestEnd) {
-					earliestStart = lastPos
-					earliestEnd = closingTagPos + len(tagPair.end)
-					isClosingOnly = true
-					isUnclosed = false
-					matchedTag = tagPair
-				}
-				continue
-			}
-
 			if startIdx == -1 {
 				continue
 			}
 			startIdx += lastPos
 
-			// Find the corresponding end tag after the start tag
-			endIdxAfterStart := strings.Index(remaining[startIdx+len(tagPair.start):], tagPair.end)
-			if endIdxAfterStart == -1 {
+			// Find the corresponding end tag
+			endIdx := strings.Index(remaining[startIdx+len(tagPair.start):], tagPair.end)
+			if endIdx == -1 {
 				// Unclosed tag - extract what we have
 				if earliestStart == -1 || startIdx < earliestStart {
 					earliestStart = startIdx
 					earliestEnd = len(remaining)
 					isUnclosed = true
-					isClosingOnly = false
 					matchedTag = tagPair
 				}
 				continue
 			}
-			endIdxAfterStart += startIdx + len(tagPair.start)
+			endIdx += startIdx + len(tagPair.start)
 
 			// Found a complete tag pair
 			if earliestStart == -1 || startIdx < earliestStart {
 				earliestStart = startIdx
-				earliestEnd = endIdxAfterStart + len(tagPair.end)
+				earliestEnd = endIdx + len(tagPair.end)
 				isUnclosed = false
-				isClosingOnly = false
 				matchedTag = tagPair
 			}
 		}
@@ -208,17 +221,6 @@ func extractFromTags(content string) (reasoning string, cleanedContent string) {
 			break
 		}
 
-		if isClosingOnly {
-			// Closing tag without opening tag - content before closing tag is reasoning
-			reasoningContent := strings.TrimSpace(remaining[lastPos : earliestEnd-len(matchedTag.end)])
-			if reasoningContent != "" {
-				reasoningParts = append(reasoningParts, reasoningContent)
-			}
-			// Move past the closing tag
-			lastPos = earliestEnd
-			continue
-		}
-
 		// Add content before the tag
 		if earliestStart > lastPos {
 			cleanedParts = append(cleanedParts, remaining[lastPos:earliestStart])

pkg/reasoning/reasoning_suite_test.go

@@ -9,5 +9,5 @@ import (
 
 func TestReasoning(t *testing.T) {
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "Reasoning Suite")
+	RunSpecs(t, "Reasoning test suite")
 }

pkg/xsysinfo/gpu.go

@@ -344,8 +344,6 @@ func getNVIDIAGPUMemory() []GPUMemoryInfo {
 			if totalBytes > 0 {
 				usagePercent = float64(usedBytes) / float64(totalBytes) * 100
 			}
-
-			xlog.Debug("using system RAM for unified memory GPU", "device", name, "system_ram_bytes", totalBytes)
 		} else if isNA {
 			// Unknown device with N/A values - skip memory info
 			xlog.Debug("nvidia-smi returned N/A for unknown device", "device", name)
@@ -569,7 +567,7 @@ func getIntelGPUTop() []GPUMemoryInfo {
 	cmd.Stderr = &stderr
 
 	if err := cmd.Run(); err != nil {
-		xlog.Debug("intel_gpu_top failed", "error", err, "stderr", stderr.String())
+		xlog.Debug("intel_gpu_top failed", "error", err, "stderr", stderr.String(), "stdout", stdout.String())
 		return nil
 	}
 

pkg/xsysinfo/memory.go

@@ -2,7 +2,6 @@ package xsysinfo
 
 import (
 	"github.com/mudler/memory"
-	"github.com/mudler/xlog"
 )
 
 // SystemRAMInfo contains system RAM usage information
@@ -25,7 +24,6 @@ func GetSystemRAMInfo() (*SystemRAMInfo, error) {
 	if total > 0 {
 		usagePercent = float64(used) / float64(total) * 100
 	}
-	xlog.Debug("System RAM Info", "total", total, "used", used, "free", free, "usage_percent", usagePercent)
 	return &SystemRAMInfo{
 		Total:        total,
 		Used:         used,

swagger/docs.go

@@ -2617,6 +2617,73 @@ const docTemplate = `{
                 }
             }
         },
+        "schema.ORAnnotation": {
+            "type": "object",
+            "properties": {
+                "end_index": {
+                    "type": "integer"
+                },
+                "start_index": {
+                    "type": "integer"
+                },
+                "title": {
+                    "type": "string"
+                },
+                "type": {
+                    "description": "url_citation",
+                    "type": "string"
+                },
+                "url": {
+                    "type": "string"
+                }
+            }
+        },
+        "schema.ORContentPart": {
+            "type": "object",
+            "properties": {
+                "annotations": {
+                    "description": "REQUIRED for output_text - must always be present (use [])",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORAnnotation"
+                    }
+                },
+                "detail": {
+                    "description": "low|high|auto for images",
+                    "type": "string"
+                },
+                "file_data": {
+                    "type": "string"
+                },
+                "file_url": {
+                    "type": "string"
+                },
+                "filename": {
+                    "type": "string"
+                },
+                "image_url": {
+                    "type": "string"
+                },
+                "logprobs": {
+                    "description": "REQUIRED for output_text - must always be present (use [])",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORLogProb"
+                    }
+                },
+                "refusal": {
+                    "type": "string"
+                },
+                "text": {
+                    "description": "REQUIRED for output_text - must always be present (even if empty)",
+                    "type": "string"
+                },
+                "type": {
+                    "description": "input_text|input_image|input_file|output_text|refusal",
+                    "type": "string"
+                }
+            }
+        },
         "schema.ORError": {
             "type": "object",
             "properties": {
@@ -2688,6 +2755,10 @@ const docTemplate = `{
                 "content": {
                     "description": "string or []ORContentPart for messages"
                 },
+                "encrypted_content": {
+                    "description": "Provider-specific encrypted content",
+                    "type": "string"
+                },
                 "id": {
                     "description": "Present for all output items",
                     "type": "string"
@@ -2706,12 +2777,42 @@ const docTemplate = `{
                     "description": "in_progress|completed|incomplete",
                     "type": "string"
                 },
+                "summary": {
+                    "description": "Reasoning fields (for type == \"reasoning\")",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORContentPart"
+                    }
+                },
                 "type": {
                     "description": "message|function_call|function_call_output|reasoning|item_reference",
                     "type": "string"
                 }
             }
         },
+        "schema.ORLogProb": {
+            "type": "object",
+            "properties": {
+                "bytes": {
+                    "type": "array",
+                    "items": {
+                        "type": "integer"
+                    }
+                },
+                "logprob": {
+                    "type": "number"
+                },
+                "token": {
+                    "type": "string"
+                },
+                "top_logprobs": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORTopLogProb"
+                    }
+                }
+            }
+        },
         "schema.OROutputTokensDetails": {
             "type": "object",
             "properties": {
@@ -2903,6 +3004,23 @@ const docTemplate = `{
                 }
             }
         },
+        "schema.ORTopLogProb": {
+            "type": "object",
+            "properties": {
+                "bytes": {
+                    "type": "array",
+                    "items": {
+                        "type": "integer"
+                    }
+                },
+                "logprob": {
+                    "type": "number"
+                },
+                "token": {
+                    "type": "string"
+                }
+            }
+        },
         "schema.ORUsage": {
             "type": "object",
             "properties": {

swagger/swagger.json

@@ -2610,6 +2610,73 @@
                 }
             }
         },
+        "schema.ORAnnotation": {
+            "type": "object",
+            "properties": {
+                "end_index": {
+                    "type": "integer"
+                },
+                "start_index": {
+                    "type": "integer"
+                },
+                "title": {
+                    "type": "string"
+                },
+                "type": {
+                    "description": "url_citation",
+                    "type": "string"
+                },
+                "url": {
+                    "type": "string"
+                }
+            }
+        },
+        "schema.ORContentPart": {
+            "type": "object",
+            "properties": {
+                "annotations": {
+                    "description": "REQUIRED for output_text - must always be present (use [])",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORAnnotation"
+                    }
+                },
+                "detail": {
+                    "description": "low|high|auto for images",
+                    "type": "string"
+                },
+                "file_data": {
+                    "type": "string"
+                },
+                "file_url": {
+                    "type": "string"
+                },
+                "filename": {
+                    "type": "string"
+                },
+                "image_url": {
+                    "type": "string"
+                },
+                "logprobs": {
+                    "description": "REQUIRED for output_text - must always be present (use [])",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORLogProb"
+                    }
+                },
+                "refusal": {
+                    "type": "string"
+                },
+                "text": {
+                    "description": "REQUIRED for output_text - must always be present (even if empty)",
+                    "type": "string"
+                },
+                "type": {
+                    "description": "input_text|input_image|input_file|output_text|refusal",
+                    "type": "string"
+                }
+            }
+        },
         "schema.ORError": {
             "type": "object",
             "properties": {
@@ -2681,6 +2748,10 @@
                 "content": {
                     "description": "string or []ORContentPart for messages"
                 },
+                "encrypted_content": {
+                    "description": "Provider-specific encrypted content",
+                    "type": "string"
+                },
                 "id": {
                     "description": "Present for all output items",
                     "type": "string"
@@ -2699,12 +2770,42 @@
                     "description": "in_progress|completed|incomplete",
                     "type": "string"
                 },
+                "summary": {
+                    "description": "Reasoning fields (for type == \"reasoning\")",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORContentPart"
+                    }
+                },
                 "type": {
                     "description": "message|function_call|function_call_output|reasoning|item_reference",
                     "type": "string"
                 }
             }
         },
+        "schema.ORLogProb": {
+            "type": "object",
+            "properties": {
+                "bytes": {
+                    "type": "array",
+                    "items": {
+                        "type": "integer"
+                    }
+                },
+                "logprob": {
+                    "type": "number"
+                },
+                "token": {
+                    "type": "string"
+                },
+                "top_logprobs": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/schema.ORTopLogProb"
+                    }
+                }
+            }
+        },
         "schema.OROutputTokensDetails": {
             "type": "object",
             "properties": {
@@ -2896,6 +2997,23 @@
                 }
             }
         },
+        "schema.ORTopLogProb": {
+            "type": "object",
+            "properties": {
+                "bytes": {
+                    "type": "array",
+                    "items": {
+                        "type": "integer"
+                    }
+                },
+                "logprob": {
+                    "type": "number"
+                },
+                "token": {
+                    "type": "string"
+                }
+            }
+        },
         "schema.ORUsage": {
             "type": "object",
             "properties": {

swagger/swagger.yaml

@@ -742,6 +742,52 @@ definitions:
       tunnelAddress:
         type: string
     type: object
+  schema.ORAnnotation:
+    properties:
+      end_index:
+        type: integer
+      start_index:
+        type: integer
+      title:
+        type: string
+      type:
+        description: url_citation
+        type: string
+      url:
+        type: string
+    type: object
+  schema.ORContentPart:
+    properties:
+      annotations:
+        description: REQUIRED for output_text - must always be present (use [])
+        items:
+          $ref: '#/definitions/schema.ORAnnotation'
+        type: array
+      detail:
+        description: low|high|auto for images
+        type: string
+      file_data:
+        type: string
+      file_url:
+        type: string
+      filename:
+        type: string
+      image_url:
+        type: string
+      logprobs:
+        description: REQUIRED for output_text - must always be present (use [])
+        items:
+          $ref: '#/definitions/schema.ORLogProb'
+        type: array
+      refusal:
+        type: string
+      text:
+        description: REQUIRED for output_text - must always be present (even if empty)
+        type: string
+      type:
+        description: input_text|input_image|input_file|output_text|refusal
+        type: string
+    type: object
   schema.ORError:
     properties:
       code:
@@ -790,6 +836,9 @@ definitions:
         type: string
       content:
         description: string or []ORContentPart for messages
+      encrypted_content:
+        description: Provider-specific encrypted content
+        type: string
       id:
         description: Present for all output items
         type: string
@@ -803,10 +852,30 @@ definitions:
       status:
         description: in_progress|completed|incomplete
         type: string
+      summary:
+        description: Reasoning fields (for type == "reasoning")
+        items:
+          $ref: '#/definitions/schema.ORContentPart'
+        type: array
       type:
         description: message|function_call|function_call_output|reasoning|item_reference
         type: string
     type: object
+  schema.ORLogProb:
+    properties:
+      bytes:
+        items:
+          type: integer
+        type: array
+      logprob:
+        type: number
+      token:
+        type: string
+      top_logprobs:
+        items:
+          $ref: '#/definitions/schema.ORTopLogProb'
+        type: array
+    type: object
   schema.OROutputTokensDetails:
     properties:
       reasoning_tokens:
@@ -931,6 +1000,17 @@ definitions:
         description: '"text" or "json_schema"'
         type: string
     type: object
+  schema.ORTopLogProb:
+    properties:
+      bytes:
+        items:
+          type: integer
+        type: array
+      logprob:
+        type: number
+      token:
+        type: string
+    type: object
   schema.ORUsage:
     properties:
       input_tokens: