server: address review feedback from ngxson

Move minimax-m2 prefix injection logic from server.cpp to chat.cpp via common_chat_stream_state

Author: ServeurpersoCom

common/chat.cpp

@@ -675,6 +675,35 @@ common_reasoning_format common_reasoning_format_from_name(const std::string & fo
     throw std::runtime_error("Unknown reasoning format: " + format);
 }
 
+void common_chat_stream_state::init(const common_chat_syntax & syntax) {
+    reasoning_prefix_streamed_ = false;
+
+    if (syntax.reasoning_format == COMMON_REASONING_FORMAT_MINIMAX_M2) {
+        reasoning_prefix_ = "<think>\n";
+    } else {
+        reasoning_prefix_.clear();
+    }
+}
+
+std::string common_chat_stream_state::apply_reasoning_prefix(const std::string & text) const {
+    if (reasoning_prefix_.empty()) {
+        return text;
+    }
+
+    std::string result(reasoning_prefix_);
+    result += text;
+    return result;
+}
+
+std::optional<std::string> common_chat_stream_state::consume_reasoning_prefix() {
+    if (!reasoning_prefix_pending()) {
+        return std::nullopt;
+    }
+
+    reasoning_prefix_streamed_ = true;
+    return reasoning_prefix_;
+}
+
 static std::string wrap_code_as_arguments(common_chat_msg_parser & builder, const std::string & code) {
     std::string arguments;
     if (builder.is_partial()) {
@@ -3169,3 +3198,12 @@ common_chat_msg common_chat_parse(const std::string & input, bool is_partial, co
     }
     return msg;
 }
+
+common_chat_msg common_chat_parse_stream(
+    const std::string & input,
+    bool is_partial,
+    common_chat_stream_state & stream_state,
+    const common_chat_syntax & syntax) {
+    const auto text_to_parse = stream_state.apply_reasoning_prefix(input);
+    return common_chat_parse(text_to_parse, is_partial, syntax);
+}

common/chat.h

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 #include <map>
+#include <optional>
 
 struct common_chat_templates;
 
@@ -159,6 +160,26 @@ struct common_chat_syntax {
     bool                     parse_tool_calls      = true;
 };
 
+struct common_chat_stream_state {
+    common_chat_stream_state() = default;
+    explicit common_chat_stream_state(const common_chat_syntax & syntax) { init(syntax); }
+
+    void init(const common_chat_syntax & syntax);
+
+    std::string apply_reasoning_prefix(const std::string & text) const;
+
+    std::optional<std::string> consume_reasoning_prefix();
+
+    bool has_reasoning_prefix() const { return !reasoning_prefix_.empty(); }
+    bool reasoning_prefix_pending() const { return has_reasoning_prefix() && !reasoning_prefix_streamed_; }
+    const std::string & reasoning_prefix() const { return reasoning_prefix_; }
+    void mark_reasoning_prefix_streamed() { reasoning_prefix_streamed_ = true; }
+
+private:
+    std::string reasoning_prefix_;
+    bool reasoning_prefix_streamed_ = false;
+};
+
 // Check if the template supplied via "--chat-template" is supported or not. Returns true if it's valid
 bool common_chat_verify_template(const std::string & tmpl, bool use_jinja);
 
@@ -200,6 +221,11 @@ const char*               common_chat_format_name(common_chat_format format);
 const char*               common_reasoning_format_name(common_reasoning_format format);
 common_reasoning_format   common_reasoning_format_from_name(const std::string & format);
 common_chat_msg           common_chat_parse(const std::string & input, bool is_partial, const common_chat_syntax & syntax);
+common_chat_msg           common_chat_parse_stream(
+    const std::string & input,
+    bool is_partial,
+    common_chat_stream_state & stream_state,
+    const common_chat_syntax & syntax);
 
 common_chat_tool_choice common_chat_tool_choice_parse_oaicompat(const std::string & tool_choice);
 

tools/server/server.cpp

@@ -1663,8 +1663,7 @@ struct server_slot {
     bool has_next_token = true;
     bool has_new_line   = false;
     bool truncated      = false;
-    bool minimax_reasoning_prefix_injected = false;
-    bool minimax_reasoning_prefix_streamed = false;
+    common_chat_stream_state reasoning_stream_state;
 
     stop_type stop;
 
@@ -1735,8 +1734,7 @@ struct server_slot {
         generated_text = "";
         has_new_line   = false;
         truncated      = false;
-        minimax_reasoning_prefix_injected = false;
-        minimax_reasoning_prefix_streamed  = false;
+        reasoning_stream_state = {};
         stop           = STOP_TYPE_NONE;
         stopping_word  = "";
         n_sent_text    = 0;
@@ -1863,14 +1861,12 @@ struct server_slot {
         GGML_ASSERT(task);
 
         auto previous_msg = chat_msg;
-        std::string text_to_parse = generated_text;
-        if (minimax_reasoning_prefix_injected) {
-            text_to_parse.insert(0, "<think>\n");
-        }
+        const auto text_to_parse = reasoning_stream_state.apply_reasoning_prefix(generated_text);
         SRV_DBG("Parsing chat message: %s\n", text_to_parse.c_str());
-        auto new_msg = common_chat_parse(
-            text_to_parse,
+        auto new_msg = common_chat_parse_stream(
+            generated_text,
             /* is_partial= */ stop != STOP_TYPE_EOS,
+            reasoning_stream_state,
             task->params.oaicompat_chat_syntax);
         if (!new_msg.empty()) {
             new_msg.set_tool_call_ids(generated_tool_call_ids, gen_tool_call_id);
@@ -2844,10 +2840,7 @@ struct server_context {
 
         slot.state = SLOT_STATE_STARTED;
 
-        const bool needs_minimax_prefix =
-            slot.task->params.oaicompat_chat_syntax.reasoning_format == COMMON_REASONING_FORMAT_MINIMAX_M2;
-        slot.minimax_reasoning_prefix_injected = needs_minimax_prefix;
-        slot.minimax_reasoning_prefix_streamed = false;
+        slot.reasoning_stream_state.init(slot.task->params.oaicompat_chat_syntax);
 
         SLT_INF(slot, "%s", "processing task\n");
 
@@ -2909,25 +2902,16 @@ struct server_context {
             slot.add_token(result);
             result.text_to_send = std::move(delta_to_send);
 
-            auto stream_with_minimax_prefix = [&](const completion_token_output & chunk) {
-                if (!slot.task->params.stream) {
-                    return;
-                }
-
-                if (slot.minimax_reasoning_prefix_injected && !slot.minimax_reasoning_prefix_streamed) {
+            if (send_text && slot.task->params.stream) {
+                if (auto prefix = slot.reasoning_stream_state.consume_reasoning_prefix()) {
                     completion_token_output prefix_chunk{};
                     prefix_chunk.tok          = LLAMA_TOKEN_NULL;
                     prefix_chunk.prob         = 0.0f;
-                    prefix_chunk.text_to_send = "<think>\n";
+                    prefix_chunk.text_to_send = *prefix;
                     send_partial_response(slot, prefix_chunk, false);
-                    slot.minimax_reasoning_prefix_streamed = true;
                 }
 
-                send_partial_response(slot, chunk, false);
-            };
-
-            if (send_text) {
-                stream_with_minimax_prefix(result);
+                send_partial_response(slot, result, false);
             }
         }
 
@@ -3098,11 +3082,7 @@ struct server_context {
         return true;
     }
 
-    void send_partial_response(
-            server_slot & slot,
-            const completion_token_output & tkn,
-            bool is_progress,
-            const std::vector<common_chat_msg_diff> * forced_diffs = nullptr) {
+    void send_partial_response(server_slot & slot, const completion_token_output & tkn, bool is_progress) {
         auto res = std::make_unique<server_task_result_cmpl_partial>();
 
         res->id    = slot.task->id;
@@ -3120,11 +3100,7 @@ struct server_context {
                 res->tokens = { tkn.tok };
             }
 
-            if (forced_diffs) {
-                res->oaicompat_msg_diffs = *forced_diffs;
-            } else {
-                slot.update_chat_msg(res->oaicompat_msg_diffs);
-            }
+            slot.update_chat_msg(res->oaicompat_msg_diffs);
         }
 
         res->n_decoded           = slot.n_decoded;
@@ -3155,12 +3131,8 @@ struct server_context {
         res->id      = slot.task->id;
         res->id_slot = slot.id;
 
-        res->index   = slot.task->index;
-        std::string response_content = slot.generated_text;
-        if (slot.minimax_reasoning_prefix_injected) {
-            response_content.insert(0, "<think>\n");
-        }
-        res->content         = std::move(response_content);
+        res->index           = slot.task->index;
+        res->content         = slot.reasoning_stream_state.apply_reasoning_prefix(slot.generated_text);
         res->tokens          = std::move(slot.generated_tokens);
         res->timings         = slot.get_timings();
         res->prompt          = slot.task->tokens.detokenize(ctx, true);