common: track think block and tool call status in chat parser

Author: aviallon

common/chat-parser-xml-toolcall.cpp

@@ -705,6 +705,9 @@ inline void parse_msg_with_xml_tool_calls(common_chat_msg_parser & builder, cons
 
     // Parse content
     bool reasoning_unclosed = builder.syntax().thinking_forced_open;
+    if (reasoning_unclosed) {
+        builder.mark_reasoning_active(end_think);
+    }
     std::string unclosed_reasoning_content("");
     for (;;) {
         auto tc = try_find_2_literal_splited_by_spaces(builder, form.scope_start, form.tool_start);
@@ -730,6 +733,7 @@ inline void parse_msg_with_xml_tool_calls(common_chat_msg_parser & builder, cons
                 }
             } else {
                 reasoning_unclosed = false;
+                builder.mark_reasoning_closed();
                 std::string reasoning_content;
                 if (pos == std::string::npos) {
                     reasoning_content = std::move(content);
@@ -766,13 +770,15 @@ inline void parse_msg_with_xml_tool_calls(common_chat_msg_parser & builder, cons
         bool toolcall_in_think = false;
         for (auto think_start = content.find(start_think); think_start != std::string::npos; think_start = content.find(start_think, think_start)) {
             if (auto think_end = content.find(end_think, think_start + start_think.size()); think_end != std::string::npos) {
+                builder.mark_reasoning_active(end_think);
                 if (builder.syntax().reasoning_format != COMMON_REASONING_FORMAT_NONE && !builder.syntax().reasoning_in_content) {
                     auto reasoning_content = content.substr(think_start + start_think.size(), think_end - think_start - start_think.size());
                     builder.add_reasoning_content(reasoning_content);
                     think_start = erase_spaces(content, think_start, think_end + end_think.size() - 1);
                 } else {
                     think_start = think_end + end_think.size() - 1;
                 }
+                builder.mark_reasoning_closed();
             } else {
                 // This <tool_call> start is in thinking block, skip this tool call
                 // This <tool_call> start is in thinking block
@@ -782,6 +788,7 @@ inline void parse_msg_with_xml_tool_calls(common_chat_msg_parser & builder, cons
                     unclosed_reasoning_content = content.substr(think_start + start_think.size()) + tool_call_start;
                 }
                 reasoning_unclosed = true;
+                builder.mark_reasoning_active(end_think);
                 content.resize(think_start);
                 toolcall_in_think = true;
             }

common/chat-parser.cpp

@@ -156,6 +156,20 @@ void common_chat_msg_parser::add_reasoning_content(const std::string &reasoning_
     result_.reasoning_content += reasoning_content;
 }
 
+void common_chat_msg_parser::mark_reasoning_active(const std::string & end_tag) {
+    result_.reasoning_status.detected = true;
+    result_.reasoning_status.active   = true;
+    if (!end_tag.empty()) {
+        result_.reasoning_status.end_tag = end_tag;
+    }
+}
+
+void common_chat_msg_parser::mark_reasoning_closed() {
+    if (result_.reasoning_status.detected) {
+        result_.reasoning_status.active = false;
+    }
+}
+
 bool common_chat_msg_parser::add_tool_call(const std::string & name, const std::string & id, const std::string & arguments) {
     if (name.empty()) {
         return false;
@@ -329,11 +343,13 @@ bool common_chat_msg_parser::try_parse_reasoning(const std::string & start_think
     const size_t saved_pos = pos_;
     const size_t saved_content_size = result_.content.size();
     const size_t saved_reasoning_size = result_.reasoning_content.size();
+    const auto   saved_reasoning_status = result_.reasoning_status;
 
     auto restore_state = [&]() {
         move_to(saved_pos);
         result_.content.resize(saved_content_size);
         result_.reasoning_content.resize(saved_reasoning_size);
+        result_.reasoning_status = saved_reasoning_status;
     };
 
     // Allow leading whitespace to be preserved as content when reasoning is present at the start
@@ -370,9 +386,11 @@ bool common_chat_msg_parser::try_parse_reasoning(const std::string & start_think
         if (whitespace_end > pos_) {
             add_content(input_.substr(pos_, whitespace_end - pos_));
         }
+        mark_reasoning_active(end_think);
         set_reasoning_prefix(cursor);
         cursor += start_think.size();
     } else if (syntax_.thinking_forced_open) {
+        mark_reasoning_active(end_think);
         cursor = whitespace_end;
     } else {
         restore_state();
@@ -398,8 +416,10 @@ bool common_chat_msg_parser::try_parse_reasoning(const std::string & start_think
 
         if (end_pos > cursor) {
             handle_reasoning(input_.substr(cursor, end_pos - cursor), /* closed */ true);
+            mark_reasoning_closed();
         } else {
             handle_reasoning("", /* closed */ true);
+            mark_reasoning_closed();
         }
 
         cursor = end_pos + end_think.size();
@@ -420,6 +440,7 @@ bool common_chat_msg_parser::try_parse_reasoning(const std::string & start_think
                 move_to(input_.size());
                 return true;
             }
+            mark_reasoning_active(end_think);
             set_reasoning_prefix(cursor);
             cursor += start_think.size();
             continue;
@@ -1492,17 +1513,24 @@ common_chat_msg common_chat_parse(const std::string & input, bool is_partial, co
         return common_chat_peg_parse(syntax.parser, input, is_partial, syntax);
     }
     common_chat_msg_parser builder(input, is_partial, syntax);
+    bool partial_exception_caught = false;
     try {
         common_chat_parse(builder);
     } catch (const common_chat_msg_partial_exception & ex) {
         LOG_DBG("Partial parse: %s\n", ex.what());
+        partial_exception_caught = true;
         if (!is_partial) {
             builder.clear_tools();
             builder.move_to(0);
             common_chat_parse_content_only(builder);
         }
     }
     auto msg = builder.result();
+    // Mark tool_call_in_progress if we caught a partial exception during partial parsing
+    // and there are tool calls in progress (indicates incomplete tool call parsing)
+    if (is_partial && partial_exception_caught && !msg.tool_calls.empty()) {
+        msg.tool_call_in_progress = true;
+    }
     if (!is_partial) {
         LOG_DBG("Parsed message: %s\n", common_chat_msgs_to_json_oaicompat<json>({msg}).at(0).dump().c_str());
     }

common/chat-parser.h

@@ -56,6 +56,10 @@ class common_chat_msg_parser {
     // Appends to the result.reasoning_content field
     void add_reasoning_content(const std::string & reasoning_content);
 
+    // Track reasoning status to expose start/end markers to callers
+    void mark_reasoning_active(const std::string & end_tag);
+    void mark_reasoning_closed();
+
     // Adds a tool call to the result. If the tool call is too incomplete (e.g. name empty), it won't add anything.
     bool add_tool_call(const std::string & name, const std::string & id, const std::string & arguments);
 

common/chat.h

@@ -22,6 +22,19 @@ struct common_chat_tool_call {
     }
 };
 
+struct common_chat_reasoning_status {
+    bool detected = false;      // a reasoning block start was observed
+    bool active   = false;      // we are currently inside a reasoning block (not closed yet)
+    std::string end_tag;        // closing tag to use when forcing a close
+
+    bool operator==(const common_chat_reasoning_status & other) const {
+        return detected == other.detected && active == other.active && end_tag == other.end_tag;
+    }
+    bool operator!=(const common_chat_reasoning_status & other) const {
+        return !(*this == other);
+    }
+};
+
 struct common_chat_msg_content_part {
     std::string type;
     std::string text;
@@ -37,6 +50,8 @@ struct common_chat_msg {
     std::vector<common_chat_msg_content_part> content_parts;
     std::vector<common_chat_tool_call> tool_calls;
     std::string reasoning_content;
+    common_chat_reasoning_status reasoning_status;
+    bool tool_call_in_progress = false;
     std::string tool_name;
     std::string tool_call_id;
 
@@ -63,6 +78,7 @@ struct common_chat_msg {
             && content_parts == other.content_parts
             && tool_calls == other.tool_calls
             && reasoning_content == other.reasoning_content
+            && reasoning_status == other.reasoning_status
             && tool_name == other.tool_name
             && tool_call_id == other.tool_call_id;
     }

tests/test-chat-parser.cpp

@@ -119,6 +119,9 @@ static void test_reasoning() {
     auto msg = common_chat_parse(input, false, syntax);
     assert_equals(variant, std::string("Pense"), msg.reasoning_content);
     assert_equals(variant, std::string("Bonjour"), msg.content);
+    assert_equals(variant, true, msg.reasoning_status.detected);
+    assert_equals(variant, false, msg.reasoning_status.active);
+    assert_equals(variant, std::string("</think>"), msg.reasoning_status.end_tag);
   }
   {
     const std::string variant("llama_3_inline_think");
@@ -133,6 +136,9 @@ static void test_reasoning() {
     auto msg = common_chat_parse(input, false, syntax);
     assert_equals(variant, std::string("Plan"), msg.reasoning_content);
     assert_equals(variant, std::string("Réponse"), msg.content);
+    assert_equals(variant, true, msg.reasoning_status.detected);
+    assert_equals(variant, false, msg.reasoning_status.active);
+    assert_equals(variant, std::string("</think>"), msg.reasoning_status.end_tag);
   }
   // Test DeepSeek V3.1 parsing - reasoning content followed by "</think>" and then regular content
   {