Reasoning and tool parser for LFM2.5

demos/common/export_models/export_model.py

@@ -54,8 +54,8 @@ def add_common_arguments(parser):
 parser_text.add_argument('--max_prompt_len', required=False, type=int, default=None, help='Sets NPU specific property for maximum number of tokens in the prompt. '
                          'Not effective if target device is not NPU', dest='max_prompt_len')
 parser_text.add_argument('--prompt_lookup_decoding', action='store_true', help='Set pipeline to use prompt lookup decoding', dest='prompt_lookup_decoding')
-parser_text.add_argument('--reasoning_parser', choices=["qwen3", "gptoss"], help='Set the type of the reasoning parser for reasoning content extraction', dest='reasoning_parser')
-parser_text.add_argument('--tool_parser', choices=["llama3", "phi4", "hermes3", "mistral", "qwen3coder", "gptoss", "devstral", "lfm2"], help='Set the type of the tool parser for tool calls extraction', dest='tool_parser')
+parser_text.add_argument('--reasoning_parser', choices=["qwen3", "gptoss", "lfm2.5", "gemma4"], help='Set the type of the reasoning parser for reasoning content extraction', dest='reasoning_parser')
+parser_text.add_argument('--tool_parser', choices=["llama3", "phi4", "hermes3", "mistral", "qwen3coder", "gptoss", "devstral", "lfm2", "gemma4"], help='Set the type of the tool parser for tool calls extraction', dest='tool_parser')
 parser_text.add_argument('--enable_tool_guided_generation', action='store_true', help='Enables enforcing tool schema during generation. Requires setting tool_parser', dest='enable_tool_guided_generation')
 
 parser_embeddings_ov = subparsers.add_parser('embeddings_ov', help='export model for embeddings endpoint with directory structure aligned with OpenVINO tools')

docs/llm/reference.md

@@ -289,8 +289,9 @@ __Tool parsers:__
 
 __Reasoning parsers:__
 - `qwen3`
-- `gemma4`
 - `gptoss`
+- `lfm2.5`
+- `gemma4`
 
 #### Automatic parser detection
 

docs/parameters.md

@@ -134,7 +134,7 @@ Task specific parameters for different tasks (text generation/image generation/e
 | `--max_prompt_len`                    | `integer`    | Sets NPU specific property for maximum number of tokens in the prompt.                                                     |
 | `--kv_cache_precision`                | `string`     | Reduced kv cache precision to `u8` lowers the cache size consumption. Accepted values: `u8` or empty (default).            |
 | `--model_distribution_policy`         | `string`     | TENSOR_PARALLEL distributes tensor to multiple sockets/devices and processes it in parallel. PIPELINE_PARALLEL distributes different tensors to process by each device. Accepted values: `TENSOR_PARALLEL`, `PIPELINE_PARALLEL` or empty (default). |
-| `--reasoning_parser`                  | `string`     | Type of parser to use for reasoning content extraction from model output. Auto-detected from chat template if not specified. Use `none` to explicitly disable. Supported: [qwen3, gptoss, gemma4]                     |
+| `--reasoning_parser`                  | `string`     | Type of parser to use for reasoning content extraction from model output. Auto-detected from chat template if not specified. Use `none` to explicitly disable. Supported: [qwen3, gptoss, lfm2.5, gemma4]                     |
 | `--tool_parser`                       | `string`     | Type of parser to use for tool calls extraction from model output. Auto-detected from chat template if not specified. Use `none` to explicitly disable. Supported: [llama3, phi4, hermes3, mistral, qwen3coder, gptoss, devstral, lfm2, gemma4]            |
 | `--enable_tool_guided_generation`     | `bool`       | Enables enforcing tool schema during generation. Requires setting response parser. Default: false.                         |
 

prepare_llm_models.sh

@@ -39,6 +39,7 @@ MISTRAL_MODEL="mistralai/Mistral-7B-Instruct-v0.3"
 GPT_OSS_MODEL="openai/gpt-oss-20b"
 DEVSTRAL_MODEL="unsloth/Devstral-Small-2507"
 LFM2_MODEL="LiquidAI/LFM2-2.6B"
+LFM25_MODEL="LiquidAI/LFM2.5-8B-A1B"
 GEMMA4_MODEL="OpenVINO/gemma-4-E4B-it-int4-ov"
 
 if [ "$(python3 -c 'import sys; print(sys.version_info[1])')" -le "8" ]; then echo "Prepare models with python > 3.8."; exit 1 ; fi
@@ -220,6 +221,16 @@ if [ ! -f "$1/$LFM2_MODEL/$TOKENIZER_FILE" ]; then
   echo "[ERROR] Models file $1/$LFM2_MODEL/$TOKENIZER_FILE does not exist."
   exit 1
 fi
+if [ -f "$1/$LFM25_MODEL/$TOKENIZER_FILE" ]; then
+  echo "Models file $1/$LFM25_MODEL/$TOKENIZER_FILE exists. Skipping downloading models."
+else
+  mkdir -p $1/$LFM25_MODEL
+  convert_tokenizer $LFM25_MODEL --with_detokenizer -o $1/$LFM25_MODEL
+fi
+if [ ! -f "$1/$LFM25_MODEL/$TOKENIZER_FILE" ]; then
+  echo "[ERROR] Models file $1/$LFM25_MODEL/$TOKENIZER_FILE does not exist."
+  exit 1
+fi
 if [ -f "$1/$GEMMA4_MODEL/$TOKENIZER_FILE" ]; then
   echo "Models file $1/$GEMMA4_MODEL/$TOKENIZER_FILE exists. Skipping downloading models."
 else

spelling-whitelist.txt

@@ -29,6 +29,7 @@ demos/vlm_npu/README.md:157: mane ==> main, many, maine
 demos/vlm_npu/README.md:218: mane ==> main, many, maine
 demos/integration_with_OpenWebUI/README.md:423: Buildin ==> Building, Build in
 src/test/llm/output_parsers/lfm2_output_parser_test.cpp
+src/test/llm/output_parsers/lfm25_output_parser_test.cpp
 windows_parse_tests.bat:35: seh ==> she
 windows_parse_tests.bat:119: SEH ==> SHE
 windows_parse_tests.bat:123: SEH ==> SHE

src/llm/BUILD

@@ -304,9 +304,9 @@ ovms_cc_library(
 )
 
 ovms_cc_library(
-    name = "io_processing_lfm2_tool_parser",
-    hdrs = ["io_processing/lfm2/lfm2_tool_parser.hpp"],
-    srcs = ["io_processing/lfm2/lfm2_tool_parser.cpp"],
+    name = "io_processing_lfm2_utils",
+    hdrs = ["io_processing/lfm2/lfm2_utils.hpp"],
+    srcs = ["io_processing/lfm2/lfm2_utils.cpp"],
     deps = [
         "@com_github_tencent_rapidjson//:rapidjson",
         "//src/port:rapidjson_document",
@@ -318,6 +318,29 @@ ovms_cc_library(
     ],
     visibility = ["//visibility:public"],
 )
+
+ovms_cc_library(
+    name = "io_processing_lfm2_tool_parser",
+    hdrs = ["io_processing/lfm2/lfm2_tool_parser.hpp"],
+    srcs = ["io_processing/lfm2/lfm2_tool_parser.cpp"],
+    deps = [
+        ":io_processing_lfm2_utils",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+
+ovms_cc_library(
+    name = "io_processing_lfm25_tool_parser",
+    hdrs = ["io_processing/lfm2/lfm25_tool_parser.hpp"],
+    srcs = ["io_processing/lfm2/lfm25_tool_parser.cpp"],
+    deps = [
+        ":io_processing_lfm2_utils",
+        "//src:libovmslogging",
+    ],
+    visibility = ["//visibility:public"],
+)
+
 ovms_cc_library(
     name = "io_processing_gemma4_tool_parser",
     hdrs = ["io_processing/gemma4/gemma4_tool_parser.hpp", "io_processing/gemma4/gemma4_reasoning_parser.hpp"],
@@ -351,6 +374,22 @@ ovms_cc_library(
     visibility = ["//visibility:public"],
 )
 
+ovms_cc_library(
+    name = "io_processing_lfm25_reasoning_parser",
+    hdrs = ["io_processing/lfm2/lfm25_reasoning_parser.hpp"],
+    srcs = ["io_processing/lfm2/lfm25_reasoning_parser.cpp"],
+    deps = [
+        "@com_github_tencent_rapidjson//:rapidjson",
+        "//src/port:rapidjson_document",
+        "//src:libovmslogging",
+        "//src:libovmsstring_utils",
+        ":io_processing_utils",
+        ":io_processing_base_output_parser",
+        "//third_party:genai",
+    ],
+    visibility = ["//visibility:public"],
+)
+
 ovms_cc_library( # TODO split further so we don't have to recompile everything when changing one parser ...
     name = "output_parsers",
     hdrs = [
@@ -386,8 +425,10 @@ ovms_cc_library( # TODO split further so we don't have to recompile everything w
         ":io_processing_parser_config_validation",
         ":io_processing_qwen3coder_tool_parser",
         ":io_processing_lfm2_tool_parser",
+        ":io_processing_lfm25_tool_parser",
         ":io_processing_gemma4_tool_parser",
         ":io_processing_qwen3_reasoning_parser",
+        ":io_processing_lfm25_reasoning_parser",
         ":io_processing_utils",
         ":apis_tool_schema_wrapper",
     ],

src/llm/io_processing/chat_template/analyzer.cpp

@@ -56,13 +56,15 @@ ChatTemplateAnalysisResult ChatTemplateAnalyzer::analyze(const std::string& temp
         return result;
     }
 
-    // TODO: It does not work for LFM2, but only for LFM2.5? Both use the same parsers
     // LFM2 detection
-    if (contains(templateSource, "<|assistant_tool_call|>") || contains(templateSource, "<|tool_call_start|>")) {
+    if (contains(templateSource, "<|assistant_tool_call|>") || contains(templateSource, "<|tool_call_start|>") || contains(templateSource, "keep_past_thinking")) {
         result.detectedToolParser = "lfm2";
         result.caps.supportsToolCalls = true;
+        if (contains(templateSource, "message.thinking")) {
+            result.caps.missnamedReasoningField = "thinking";
+            result.detectedReasoningParser = "lfm2.5";
+        }
         return result;
-        // TODO: Support reasoning after Pawel adds reasoning parser for it
     }
 
     // Phi-4 detection — uses "functools[" marker for tool calls

src/llm/io_processing/chat_template/caps.hpp

@@ -25,13 +25,16 @@ struct ChatTemplateCaps {
     // Some templates require tool_call arguments to be a dict/object rather than a stringified JSON.
     bool requiresObjectArguments = false;
 
+    std::string missnamedReasoningField = "";
+
     bool needsWorkarounds() const {
-        return requiresObjectArguments;
+        return requiresObjectArguments || !missnamedReasoningField.empty();
     }
 
     std::string toString() const {
         return std::string("supportsToolCalls=") + (supportsToolCalls ? "true" : "false") +
-               ", requiresObjectArguments=" + (requiresObjectArguments ? "true" : "false");
+               ", requiresObjectArguments=" + (requiresObjectArguments ? "true" : "false") +
+               ", missnamedReasoningField=" + missnamedReasoningField;
     }
 };
 

src/llm/io_processing/input_processors/chat_template_adapter.cpp

@@ -60,11 +60,27 @@ void funcArgsToObjectHistory(ov::genai::ChatHistory& chatHistory) {
     }
 }
 
+void injectReasoningIntoMissnamedSection(ov::genai::ChatHistory& chatHistory, const std::string& templateReasoningFieldName) {
+    for (size_t msgIdx = 0; msgIdx < chatHistory.size(); ++msgIdx) {
+        auto message = chatHistory[msgIdx];
+        if (!message.contains("reasoning_content")) {
+            continue;
+        }
+        auto reasoning = message["reasoning_content"];
+        std::string contentStr = reasoning.get_string();
+
+        message[templateReasoningFieldName.c_str()] = contentStr;
+    }
+}
+
 void applyToHistory(const ChatTemplateCaps& caps, ov::genai::ChatHistory& chatHistory) {
     SPDLOG_LOGGER_TRACE(llm_calculator_logger, "Applying chat template adaptations: {}", caps.toString());
     if (caps.requiresObjectArguments) {
         funcArgsToObjectHistory(chatHistory);
     }
+    if (!caps.missnamedReasoningField.empty()) {
+        injectReasoningIntoMissnamedSection(chatHistory, caps.missnamedReasoningField);
+    }
 }
 
 }  // namespace chat_template_adapter

src/llm/io_processing/lfm2/lfm25_reasoning_parser.cpp

@@ -0,0 +1,72 @@
+//*****************************************************************************
+// Copyright 2026 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+#include <openvino/genai/tokenizer.hpp>
+#include <string>
+#include <vector>
+
+#include "src/port/rapidjson_document.hpp"
+
+#include "../../../logging.hpp"
+#include "lfm25_reasoning_parser.hpp"
+#include "../utils.hpp"
+
+namespace ovms {
+void Lfm25ReasoningParser::parse(ParsedOutput& parsedOutput, const std::vector<int64_t>& generatedTokens) {
+    auto startReasoningIt = std::find(generatedTokens.begin(), generatedTokens.end(), reasoningStartTokenId);
+    auto endReasoningIt = std::find(generatedTokens.begin(), generatedTokens.end(), reasoningEndTokenId);
+
+    if (startReasoningIt == generatedTokens.end() || endReasoningIt == generatedTokens.end() || startReasoningIt >= endReasoningIt) {
+        SPDLOG_LOGGER_DEBUG(llm_calculator_logger, "Lfm25ReasoningParser: Reasoning start or end token not found in the generated tokens, or in wrong order. Start token found: {}, End token found: {}, Start position: {}, End position: {}",
+            startReasoningIt != generatedTokens.end(), endReasoningIt != generatedTokens.end(), std::distance(generatedTokens.begin(), startReasoningIt), std::distance(generatedTokens.begin(), endReasoningIt));
+        return;
+    }
+
+    auto startPos = std::distance(generatedTokens.begin(), startReasoningIt);
+    auto endPos = std::distance(generatedTokens.begin(), endReasoningIt);
+
+    std::string reasoningContent = tokenizer.decode(std::vector<int64_t>(startPos + generatedTokens.begin() + 1, endPos + generatedTokens.begin()), ov::genai::skip_special_tokens(true));
+
+    parsedOutput.reasoning = reasoningContent;
+
+    std::string contentWithoutReasoning = tokenizer.decode(std::vector<int64_t>(generatedTokens.begin() + endPos + 1, generatedTokens.end()), ov::genai::skip_special_tokens(true));  // content MUST never appear before reasoning
+    parsedOutput.content = contentWithoutReasoning;
+}
+
+std::optional<rapidjson::Document> Lfm25ReasoningParser::parseChunk(const std::string& chunk, const std::vector<int64_t>& tokens, ov::genai::GenerationFinishReason finishReason) {
+    if (tokens.empty()) {
+        SPDLOG_LOGGER_DEBUG(llm_calculator_logger, "Received empty tokens for Lfm25ReasoningParser");
+        return std::nullopt;
+    }
+
+    if (std::find(tokens.begin(), tokens.end(), reasoningStartTokenId) != tokens.end() ||
+        std::find(tokens.begin(), tokens.end(), reasoningEndTokenId) != tokens.end()) {
+        return std::nullopt;
+    } else {
+        rapidjson::StringBuffer buffer;
+        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+        writer.StartObject();
+        writer.String("delta");
+        writer.StartObject();
+        writer.String("reasoning_content");
+        writer.String(chunk.c_str());
+        writer.EndObject();
+        writer.EndObject();
+        rapidjson::Document doc;
+        doc.Parse(buffer.GetString());
+        return doc;
+    }
+}
+}  // namespace ovms

src/llm/io_processing/lfm2/lfm25_reasoning_parser.hpp

@@ -0,0 +1,54 @@
+//*****************************************************************************
+// Copyright 2026 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+#pragma once
+#include "../base_output_parser.hpp"
+#include <vector>
+#include <string>
+
+namespace ovms {
+class Lfm25ReasoningParser : public BaseOutputParser {
+protected:
+    const std::string parsingStartTag = "<think>";
+    const std::string parsingEndTag = "</think>";
+
+    const int64_t reasoningStartTokenId = 124901;  // <think>
+    const int64_t reasoningEndTokenId = 124902;    // </think>
+
+public:
+    Lfm25ReasoningParser() = delete;
+    explicit Lfm25ReasoningParser(ov::genai::Tokenizer& tokenizer) :
+        BaseOutputParser(tokenizer) {}
+
+    void parse(ParsedOutput& parsedOutput, const std::vector<int64_t>& generatedTokens) override;
+    std::optional<rapidjson::Document> parseChunk(const std::string& chunk, const std::vector<int64_t>& tokens, ov::genai::GenerationFinishReason finishReason) override;
+    const std::vector<std::string>& getParsingStartTags() const override {
+        static const std::vector<std::string> parsingStartTags{this->parsingStartTag};
+        return parsingStartTags;
+    }
+    const std::vector<std::string>& getSpecialParsingStartTags() const override {
+        static const std::vector<std::string> specialParsingStartTags{};
+        return specialParsingStartTags;
+    }
+    const std::string& getParsingEndTag() const override {
+        return parsingEndTag;
+    }
+
+    // It may be removed after changing logic in Lfm2ToolParser to use tokens in streaming instead of chunk content, both tool parser and reasoning parser need to have the same value for this function
+    bool requiresStreamingWithSpecialTokens() const override {
+        return true;
+    }
+};
+}  // namespace ovms