Add parsing

src/cpp/include/openvino/genai/generation_config.hpp

@@ -13,6 +13,7 @@
 #include "openvino/genai/tokenizer.hpp"
 #include "openvino/genai/scheduler_config.hpp"
 #include "openvino/genai/lora_adapter.hpp"
+#include "openvino/genai/parsers.hpp"
 
 namespace ov {
 namespace genai {
@@ -348,6 +349,9 @@ class OPENVINO_GENAI_EXPORTS GenerationConfig {
     bool is_prompt_lookup() const;
     bool is_structured_output_generation() const;
 
+    // parsers
+    std::vector<std::shared_ptr<ParserBase>> parsers;
+
     OPENVINO_DEPRECATED("Please, use `is_assisting_generation()` instead of `is_speculative_decoding()`. This method will be removed in 2026.0.0 release")
     bool is_speculative_decoding() const;
 

src/cpp/include/openvino/genai/llm_pipeline.hpp

@@ -15,6 +15,7 @@
 #include "openvino/genai/perf_metrics.hpp"
 #include "openvino/genai/scheduler_config.hpp"
 #include "openvino/genai/common_types.hpp"
+#include "openvino/genai/json_container.hpp"
 
 namespace ov {
 namespace genai {
@@ -68,6 +69,7 @@ class DecodedResults {
     std::vector<float> scores;
     PerfMetrics perf_metrics;
     std::shared_ptr<ExtendedPerfMetrics> extended_perf_metrics;
+    std::vector<JsonContainer> parsed;
 
     // @brief Convert DecodedResults to a string.
     operator std::string() const {

src/cpp/include/openvino/genai/parsers.hpp

@@ -0,0 +1,96 @@
+// Copyright (C) 2023-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#include <string>
+#include <memory>
+#include <vector>
+#include "openvino/genai/json_container.hpp"
+
+namespace ov {
+namespace genai {
+
+class IncrementalParserBase {
+public:
+    IncrementalParserBase() = default;
+
+    // We return string which with filtered text to be added to content.
+    virtual std::string parse(
+        JsonContainer& msg,
+        const std::string& previous_text, 
+        std::string& delta_text, 
+        const std::optional<std::vector<int64_t>>& previous_tokens = std::nullopt, 
+        const std::optional<std::vector<int64_t>>& delta_tokens = std::nullopt
+    ) = 0;
+};
+
+class ReasoningParser : public IncrementalParserBase {
+private:
+    class ReasoningParserImpl;
+    std::shared_ptr<ReasoningParserImpl> m_impl;
+public:
+    ReasoningParser(bool expect_open_tag = true,
+                    bool keep_original_content = true, 
+                    const std::string& open_tag = "<think>", 
+                    const std::string& close_tag = "</think>");
+
+    std::string parse(
+        JsonContainer& msg,
+        const std::string& previous_text, 
+        std::string& delta_text,
+        const std::optional<std::vector<int64_t>>& previous_tokens = std::nullopt, 
+        const std::optional<std::vector<int64_t>>& delta_tokens = std::nullopt
+    ) override;
+};
+
+class DeepSeekR1ReasoningParser : public ReasoningParser {
+public:
+    explicit DeepSeekR1ReasoningParser(bool expect_open_tag = true) : ReasoningParser(expect_open_tag) {};
+};
+
+class Phi4ReasoningParser : public ReasoningParser {
+public:
+    explicit Phi4ReasoningParser(bool expect_open_tag = false) : ReasoningParser(expect_open_tag) {};
+};
+
+class ParserBase {
+public:
+    ParserBase() = default;
+    virtual void parse(JsonContainer& text) = 0;
+};
+
+class Llama32PythonicToolParser : public ParserBase {
+// Does not modify original content, only extracts and adds tool calls
+public:
+    explicit Llama32PythonicToolParser(bool keep_original_content = true);
+    void parse(JsonContainer& input) override;
+private:
+    class Llama32PythonicToolParserImpl;
+    std::shared_ptr<Llama32PythonicToolParserImpl> m_impl;
+};
+
+class Llama32JsonToolParser : public ParserBase {
+// Does not modify original content, only extracts and adds tool calls
+public:
+    explicit Llama32JsonToolParser(bool keep_original_content = true);
+    void parse(JsonContainer& input) override;
+private:
+    class Llama32JsonToolParserImpl;
+    std::shared_ptr<Llama32JsonToolParserImpl> m_impl;
+};
+
+class BaseReasoningParser : public ParserBase{
+public:
+    BaseReasoningParser(
+        bool expect_open_tag = true, 
+        bool keep_original_content = true, 
+        const std::string& open_tag = "<think>", 
+        const std::string& close_tag = "</think>");
+    void parse(JsonContainer& input) override;
+private:
+    class BaseReasoningParserImpl;
+    std::shared_ptr<BaseReasoningParserImpl> m_impl;
+};
+
+}  // namespace genai
+}  // namespace ov

src/cpp/include/openvino/genai/text_streamer.hpp

@@ -5,6 +5,7 @@
 
 #include "openvino/genai/streamer_base.hpp"
 #include "openvino/genai/tokenizer.hpp"
+#include "openvino/genai/parsers.hpp"
 
 namespace ov {
 namespace genai {
@@ -46,5 +47,20 @@ class OPENVINO_GENAI_EXPORTS TextStreamer : public StreamerBase {
     void compute_decoded_length_for_position(size_t cache_position);
 };
 
+class TextParserStreamer : public TextStreamer {
+public:
+    TextParserStreamer(const Tokenizer& tokenizer, std::vector<std::shared_ptr<IncrementalParserBase>> parsers = {});
+
+    virtual StreamingStatus write(JsonContainer& message) = 0;
+
+    CallbackTypeVariant write(std::string message);
+
+    JsonContainer get_parsed_message() const { return m_parsed_message; }
+private:
+    JsonContainer m_parsed_message;
+    std::string m_text_buffer;
+    std::vector<std::shared_ptr<IncrementalParserBase>> m_parsers;
+};
+
 }  // namespace genai
 }  // namespace ov

src/cpp/src/generation_config.cpp

@@ -153,6 +153,7 @@ void GenerationConfig::update_generation_config(const ov::AnyMap& properties) {
 
     // Structured output
     read_anymap_param(properties, "structured_output_config", structured_output_config);
+    read_anymap_param(properties, "parsers", parsers);
 }
 
 

src/cpp/src/llm/pipeline.cpp

@@ -205,7 +205,38 @@ DecodedResults LLMPipeline::generate(
         StringInputs inputs,
         OptionalGenerationConfig generation_config,
         StreamerVariant streamer) {
-    return m_pimpl->generate(inputs, generation_config, streamer);
+    auto res = m_pimpl->generate(inputs, generation_config, streamer);
+
+    // If streamer is of StreamerBase type, and it is TextParserStreamer, get parsed message
+    if (auto streamer_obj = std::get_if<std::shared_ptr<StreamerBase>>(&streamer)) {
+        if (auto parser_streamer = std::dynamic_pointer_cast<TextParserStreamer>(*streamer_obj)) {
+            res.parsed.resize(res.texts.size());
+            res.parsed[0] = parser_streamer->get_parsed_message();
+        }
+    }
+
+    if (!generation_config.has_value() || (*generation_config).parsers.empty()) {
+        return res;
+    }
+
+    if (!generation_config.has_value()  || (*generation_config).parsers.empty()) {
+        return res;
+    }
+
+    std::vector<std::shared_ptr<ParserBase>> parsers = (*generation_config).parsers;
+    res.parsed.resize(res.texts.size());
+    // Apply Base parsers sequentially even if IncrementalParser has run.
+    for (size_t i = 0; i < res.texts.size(); ++i) {
+        JsonContainer msg;
+        msg["content"] = res.texts[i];
+        for (auto& parser: parsers) {
+            // TODO: Check the state of incremental parser and reset if necessary
+            parser->parse(msg);
+        }
+        res.parsed[i] = msg;
+    }
+
+    return res;
 }
 
 DecodedResults LLMPipeline::generate(StringInputs text, const ov::AnyMap& config_map) {