server: filter partial tool call streams

Expose stable tool-call headers early for client UX, but quarantine partial arguments and malformed raw tool markers until the parser sees a complete call.

Accept direct tag-style function starts such as <function=...> for Qwen-style tool calls and include structural markers in lazy grammar triggers.

Fixes #6

Author: Anbeeld

common/chat-auto-parser-generator.cpp

@@ -13,6 +13,10 @@
 
 using json = nlohmann::ordered_json;
 
+static bool is_structural_tool_marker(const std::string & marker) {
+    return !marker.empty() && (marker[0] == '<' || marker[0] == '[');
+}
+
 // Helper to iterate over tools/functions
 static void foreach_function(const json & tools, const std::function<void(const json &)> & fn) {
     for (const auto & tool : tools) {
@@ -76,11 +80,30 @@ common_chat_params peg_generator::generate_parser(const common_chat_template &
             parser.build_grammar(builder, data.grammar_lazy);
         });
 
-        // Set grammar triggers based on tool section markers (fall back to per-call markers)
+        // Set grammar triggers based on tool section markers (fall back to per-call markers).
+        // Some tag-style models occasionally skip the outer per-call wrapper and start
+        // directly at the function marker; trigger there too if it is a structural marker.
         if (data.grammar_lazy) {
-            data.grammar_triggers = {
-                { COMMON_GRAMMAR_TRIGGER_TYPE_WORD, trigger_marker }
+            std::vector<std::string> trigger_markers = {
+                autoparser.tools.format.section_start,
+                autoparser.tools.format.per_call_start,
             };
+            if (is_structural_tool_marker(autoparser.tools.function.name_prefix)) {
+                trigger_markers.push_back(autoparser.tools.function.name_prefix);
+            }
+
+            for (const std::string & marker : trigger_markers) {
+                if (marker.empty()) {
+                    continue;
+                }
+                bool exists = false;
+                for (const auto & trigger : data.grammar_triggers) {
+                    exists = exists || trigger.value == marker;
+                }
+                if (!exists) {
+                    data.grammar_triggers.push_back({ COMMON_GRAMMAR_TRIGGER_TYPE_WORD, marker });
+                }
+            }
         }
     }
 
@@ -440,12 +463,16 @@ common_peg_parser analyze_tools::build_tool_parser_tag_tagged(parser_build_conte
 
     common_peg_parser tool_calls = p.eps();
 
+    const bool allow_direct_func_start =
+        is_structural_tool_marker(function.name_prefix) && !function.close.empty();
+
     if (!format.per_call_start.empty()) {
         auto wrapped_call = format.per_call_start + p.space() + tool_choice + p.space() + format.per_call_end;
+        auto single_call  = allow_direct_func_start ? (wrapped_call | tool_choice) : wrapped_call;
         if (inputs.parallel_tool_calls) {
-            tool_calls = p.trigger_rule("tool-call", wrapped_call + p.zero_or_more(p.space() + wrapped_call) + p.space());
+            tool_calls = p.trigger_rule("tool-call", single_call + p.zero_or_more(p.space() + single_call) + p.space());
         } else {
-            tool_calls = p.trigger_rule("tool-call", wrapped_call + p.space());
+            tool_calls = p.trigger_rule("tool-call", single_call + p.space());
         }
         if (!format.section_start.empty()) {
             tool_calls = p.trigger_rule("tool-calls",
@@ -469,8 +496,17 @@ common_peg_parser analyze_tools::build_tool_parser_tag_tagged(parser_build_conte
         tool_calls = p.optional(tool_calls);
     }
 
-    std::string trigger_marker       = !format.section_start.empty() ? format.section_start : format.per_call_start;
-    auto        content_before_tools = trigger_marker.empty() ? p.eps() : p.until(trigger_marker);
+    std::vector<std::string> trigger_markers;
+    if (!format.section_start.empty()) {
+        trigger_markers.push_back(format.section_start);
+    }
+    if (!format.per_call_start.empty()) {
+        trigger_markers.push_back(format.per_call_start);
+    }
+    if (allow_direct_func_start) {
+        trigger_markers.push_back(function.name_prefix);
+    }
+    auto content_before_tools = trigger_markers.empty() ? p.eps() : p.until_one_of(trigger_markers);
     return ctx.reasoning_parser + (force_tools ? p.eps() : p.optional(p.content(content_before_tools))) + tool_calls +
            p.end();
 }

tools/server/server-task.cpp

@@ -244,6 +244,252 @@ json task_params::to_json(bool only_metrics) const {
 //
 // task_result_state
 //
+static bool task_result_has_explicit_tool_call_marker(const std::string & text);
+
+static bool task_result_has_complete_partial_tool_calls(
+        const std::string     & generated_text,
+        const common_chat_msg & msg) {
+    if (msg.tool_calls.empty()) {
+        return false;
+    }
+
+    for (const auto & tc : msg.tool_calls) {
+        if (tc.name.empty() || tc.arguments.empty()) {
+            return false;
+        }
+    }
+
+    const size_t end = generated_text.find_last_not_of(" \t\r\n");
+    if (end == std::string::npos) {
+        return false;
+    }
+
+    const size_t start = end > 512 ? end - 512 : 0;
+    const std::string tail = generated_text.substr(start, end - start + 1);
+
+    static const char * closing_markers[] = {
+        "</tool_call>",
+        "</function>",
+        "</seed:tool_call>",
+        "</minimax:tool_call>",
+        "</TOOLCALL>",
+        "<|tool_call_end|>",
+        "<|tool_calls_section_end|>",
+        "<tool_call|>",
+    };
+    for (const char * marker : closing_markers) {
+        if (tail.find(marker) != std::string::npos) {
+            return true;
+        }
+    }
+
+    // Check full generated_text, not only tail. A long argument can push the
+    // opening marker outside the 512-byte tail window. In tagged formats,
+    // JSON/object closure alone is not completion.
+    if (task_result_has_explicit_tool_call_marker(generated_text)) {
+        return false;
+    }
+
+    const char last = generated_text[end];
+    return last == '}' || last == ']' || last == ')';
+}
+
+static bool task_result_pos_is_in_code_fence(
+        const std::string & text,
+        size_t              pos) {
+    bool in_fence = false;
+    size_t search = 0;
+    while (search < pos) {
+        const size_t fence = text.find("```", search);
+        if (fence == std::string::npos || fence >= pos) {
+            break;
+        }
+        in_fence = !in_fence;
+        search = fence + 3;
+    }
+    return in_fence;
+}
+
+static bool task_result_raw_tool_marker_has_boundary(
+        const std::string & text,
+        size_t              pos) {
+    if (pos == 0) {
+        return true;
+    }
+
+    const char prev = text[pos - 1];
+    return prev == '\n' || prev == '\r' || prev == '\t' || prev == ' ' || prev == '>';
+}
+
+static size_t task_result_find_raw_tool_marker(
+        const std::string & text,
+        size_t              search_from) {
+    static const char * markers[] = {
+        "<tool_call",
+        "<function=",
+        "<parameter=",
+        "<|tool_calls_section_begin|>",
+        "<|tool_call_begin|>",
+        "<|tool_call_start|>",
+        "<seed:tool_call",
+        "<minimax:tool_call",
+        "<TOOLCALL",
+    };
+
+    size_t best = std::string::npos;
+    for (const char * marker : markers) {
+        size_t pos = text.find(marker, search_from);
+        while (pos != std::string::npos) {
+            if (task_result_raw_tool_marker_has_boundary(text, pos) &&
+                    !task_result_pos_is_in_code_fence(text, pos)) {
+                best = best == std::string::npos ? pos : std::min(best, pos);
+                break;
+            }
+            pos = text.find(marker, pos + 1);
+        }
+    }
+
+    return best;
+}
+
+static bool task_result_has_explicit_tool_call_marker(const std::string & text) {
+    return task_result_find_raw_tool_marker(text, 0) != std::string::npos;
+}
+
+static bool task_result_starts_with_raw_tool_marker(const std::string & text) {
+    const size_t marker = task_result_find_raw_tool_marker(text, 0);
+    if (marker == std::string::npos) {
+        return false;
+    }
+
+    const size_t first = text.find_first_not_of(" \t\r\n");
+    return first != std::string::npos && marker == first;
+}
+
+static void task_result_quarantine_raw_tool_text_field(
+        std::string       & text,
+        const std::string & previous) {
+    if (text.size() <= previous.size()) {
+        return;
+    }
+
+    const size_t search_from = previous.size() > 64 ? previous.size() - 64 : 0;
+    const size_t marker = task_result_find_raw_tool_marker(text, search_from);
+    if (marker == std::string::npos) {
+        return;
+    }
+
+    // Keep all text that was already streamed. If a malformed raw tool marker
+    // appears in newly parsed content/reasoning, quarantine it until it becomes
+    // a parsed tool call instead of visible assistant text.
+    if (marker < previous.size()) {
+        text = previous;
+    } else {
+        text.resize(marker);
+    }
+}
+
+static void task_result_quarantine_raw_tool_text(
+        common_chat_msg       & new_msg,
+        const common_chat_msg & msg_prv) {
+    if (new_msg.tool_calls.size() > msg_prv.tool_calls.size()) {
+        return;
+    }
+
+    task_result_quarantine_raw_tool_text_field(new_msg.content, msg_prv.content);
+    task_result_quarantine_raw_tool_text_field(new_msg.reasoning_content, msg_prv.reasoning_content);
+}
+
+static void task_result_freeze_text_fields(
+        common_chat_msg       & new_msg,
+        const common_chat_msg & msg_prv) {
+    new_msg.content = msg_prv.content;
+    new_msg.content_parts = msg_prv.content_parts;
+    new_msg.reasoning_content = msg_prv.reasoning_content;
+}
+
+static bool task_result_has_marker_after_anchor(
+        const std::string & generated_text,
+        const std::string & anchor) {
+    if (anchor.empty()) {
+        return false;
+    }
+
+    const size_t pos = generated_text.rfind(anchor);
+    if (pos == std::string::npos) {
+        return false;
+    }
+
+    const size_t tail_len = std::min<size_t>(generated_text.size() - pos, 512);
+    const std::string tail = generated_text.substr(pos, tail_len);
+
+    static const char * argument_markers[] = {
+        "<|tool_call_argument_begin|>",
+        "<parameter=",
+        "\"arguments\"",
+        "'arguments'",
+        "arguments:",
+        "arguments=",
+    };
+    for (const char * marker : argument_markers) {
+        if (tail.find(marker) != std::string::npos) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static bool task_result_has_stable_partial_tool_call_header(
+        const std::string           & generated_text,
+        const common_chat_tool_call & tc) {
+    if (tc.name.empty()) {
+        return false;
+    }
+
+    // Arguments present in the parsed result does not guarantee a stable header
+    // for streaming purposes. The parser may have only started argument parsing
+    // (e.g. just "{"). Only consider the header stable when the generated text
+    // has argument markers after the tool call name/id anchor.
+    return task_result_has_marker_after_anchor(generated_text, tc.id) ||
+           task_result_has_marker_after_anchor(generated_text, tc.name);
+}
+
+static void task_result_filter_incomplete_partial_tool_calls(
+        const std::string     & generated_text,
+        common_chat_msg       & new_msg,
+        const common_chat_msg & msg_prv) {
+    std::vector<common_chat_tool_call> filtered;
+    filtered.reserve(std::max(new_msg.tool_calls.size(), msg_prv.tool_calls.size()));
+
+    for (size_t i = 0; i < new_msg.tool_calls.size(); ++i) {
+        common_chat_tool_call tc = new_msg.tool_calls[i];
+        if (i < msg_prv.tool_calls.size()) {
+            if (tc.name.empty()) {
+                tc.name = msg_prv.tool_calls[i].name;
+            }
+            if (tc.id.empty()) {
+                tc.id = msg_prv.tool_calls[i].id;
+            }
+        }
+
+        if (!task_result_has_stable_partial_tool_call_header(generated_text, tc)) {
+            break;
+        }
+
+        // A partial stream may expose the stable tool name/id for UX, but the
+        // arguments remain hidden until a complete call is parsed.
+        tc.arguments = i < msg_prv.tool_calls.size() ? msg_prv.tool_calls[i].arguments : "";
+        filtered.push_back(std::move(tc));
+    }
+
+    while (filtered.size() < msg_prv.tool_calls.size()) {
+        filtered.push_back(msg_prv.tool_calls[filtered.size()]);
+    }
+
+    new_msg.tool_calls = std::move(filtered);
+}
+
 common_chat_msg task_result_state::update_chat_msg(
         const std::string & text_added,
         bool is_partial,
@@ -258,6 +504,19 @@ common_chat_msg task_result_state::update_chat_msg(
         chat_parser_params);
     if (!new_msg.empty()) {
         new_msg.set_tool_call_ids(generated_tool_call_ids, gen_tool_call_id);
+        if (filter_tool_calls && chat_parser_params.parse_tool_calls) {
+            const bool has_complete_tool_calls = task_result_has_complete_partial_tool_calls(generated_text, new_msg);
+            if (!new_msg.tool_calls.empty() &&
+                    (!has_complete_tool_calls || task_result_starts_with_raw_tool_marker(generated_text))) {
+                task_result_freeze_text_fields(new_msg, msg_prv_copy);
+            }
+            if (!has_complete_tool_calls) {
+                task_result_quarantine_raw_tool_text(new_msg, msg_prv_copy);
+            }
+            if (!has_complete_tool_calls) {
+                task_result_filter_incomplete_partial_tool_calls(generated_text, new_msg, msg_prv_copy);
+            }
+        }
         chat_msg = new_msg;
         auto all_diffs = common_chat_msg_diff::compute_diffs(msg_prv_copy, chat_msg);
 
@@ -292,7 +551,7 @@ common_chat_msg task_result_state::update_chat_msg(
                         }
                     } else {
                         // Not sent yet.
-                        if (!d.tool_call_delta.arguments.empty() || !is_partial) {
+                        if (!d.tool_call_delta.name.empty() || !d.tool_call_delta.arguments.empty() || !is_partial) {
                             d.tool_call_delta.name = chat_msg.tool_calls[i].name;
                             d.tool_call_delta.id   = chat_msg.tool_calls[i].id;
                             diffs.push_back(std::move(d));
@@ -1525,7 +1784,7 @@ json server_task_result_cmpl_final::to_json_anthropic_stream() {
 //
 void server_task_result_cmpl_partial::update(task_result_state & state) {
     is_updated = true;
-    state.update_chat_msg(content, true, oaicompat_msg_diffs);
+    state.update_chat_msg(content, true, oaicompat_msg_diffs, true);
 
     // Copy current state for use in to_json_*() (reflects state BEFORE this chunk)
     thinking_block_started = state.thinking_block_started;

tools/server/server-task.h

@@ -388,7 +388,7 @@ struct server_task_result_cmpl_final : server_task_result {
 
     virtual void update(task_result_state & state) override {
         is_updated = true;
-        oaicompat_msg = state.update_chat_msg(content, false, oaicompat_msg_diffs);
+        oaicompat_msg = state.update_chat_msg(content, false, oaicompat_msg_diffs, stream);
 
         oai_resp_id = state.oai_resp_id;
         oai_resp_reasoning_id = state.oai_resp_reasoning_id;