tool calling xml issue fixed, but tool type is still having issues

Author: 22bruce

.github/chatmodes/custom_models.chatmode.md

@@ -1331,62 +1331,235 @@ static void common_chat_parse_gpt_oss(common_chat_msg_parser & builder) {
 
 static common_chat_params common_chat_params_init_glm_4_5(const common_chat_template & tmpl, const struct templates_params & inputs) {
     common_chat_params data;
-    data.prompt = apply(tmpl, inputs);
+    
+    // Bypass minja's tool processing entirely
+    minja::chat_template_inputs tmpl_inputs;
+    tmpl_inputs.messages = inputs.messages;
+    tmpl_inputs.tools = inputs.tools.empty() ? json() : inputs.tools;
+    tmpl_inputs.add_generation_prompt = inputs.add_generation_prompt;
+    tmpl_inputs.extra_context = inputs.extra_context;
+    tmpl_inputs.now = std::chrono::system_clock::now();
+    
+    // Force XML mode through context
+    tmpl_inputs.extra_context["xml_tool_format"] = true;
+    tmpl_inputs.extra_context["native_tool_support"] = true;
+
+    minja::chat_template_options opts;
+    opts.apply_polyfills = false;        // Hard disable all polyfills
+    opts.use_bos_token = inputs.add_bos;
+    opts.use_eos_token = inputs.add_eos;
+    
+    // Single apply call
+    auto result = tmpl.apply(tmpl_inputs, opts);
+    
+    // Manual BOS/EOS handling (since you disabled automatic handling)
+    if (inputs.add_bos && string_starts_with(result, tmpl.bos_token())) {
+        result = result.substr(tmpl.bos_token().size());
+    }
+    if (inputs.add_eos && string_ends_with(result, tmpl.eos_token())) {
+        result = result.substr(0, result.size() - tmpl.eos_token().size());
+    }
+    
+    data.prompt = result;
     data.format = COMMON_CHAT_FORMAT_GLM_4_5;
+    data.preserved_tokens = {
+        "<|system|>", "<|assistant|>", "<|observation|>",
+        "<tool_call>", "</tool_call>", "<arg_key>", "</arg_key>", 
+        "<arg_value>", "</arg_value>", "<think>", "</think>",
+        "<tool_response>", "</tool_response>",
+    };
+    
+    // Store tools schema for type-aware parsing
+    data.tools_schema = inputs.tools;
+    
     return data;
 }
 
-static void common_chat_parse_glm_4_5(common_chat_msg_parser & builder) {
-    builder.consume_spaces();
-    builder.try_parse_reasoning("<think>", "</think>");
-    if (!builder.syntax().parse_tool_calls) {
-        builder.add_content(builder.consume_rest());
-        return;
-    }
+static void debug_print_raw_input(const std::string& input) {
+    LOG_INF("=== GLM-4.5 RAW INPUT ===\n");
+    for (size_t i = 0; i < input.size(); ++i) {
+        char ch = input[i];
+        if (ch == '\n') LOG_INF("\\n");
+        else if (ch == '\t') LOG_INF("\\t");
+        else if (ch == '\r') LOG_INF("\\r");
+        else if (std::isspace(ch)) LOG_INF("·"); // visible space
+        else LOG_INF("%c", ch);
+    }
+    LOG_INF("\n=== END RAW INPUT ===\n");
+}
 
-    // GLM 4.5 uses format: <tool_call>function_name\n<arg_key>key</arg_key>\n<arg_value>value</arg_value>\n</tool_call>
-    static const common_regex tool_call_start("<tool_call>([^\n<]+)");
-    static const common_regex arg_key_regex("<arg_key>([^<]+)</arg_key>");
-    static const common_regex arg_value_regex("<arg_value>([\\s\\S]*?)</arg_value>");
-    static const common_regex tool_call_end("</tool_call>");
+static void debug_print_parse_position(const std::string& input, size_t pos, const char* context) {
+    size_t start = (pos < 50) ? 0 : pos - 50;
+    size_t end = std::min(input.size(), pos + 50);
+    LOG_INF("=== %s at position %zu ===\n", context, pos);
+    for (size_t i = start; i < end; ++i) {
+        if (i == pos) LOG_INF(">>>");
+        char ch = input[i];
+        if (ch == '\n') LOG_INF("\\n");
+        else if (ch == '\t') LOG_INF("\\t");
+        else LOG_INF("%c", ch);
+        if (i == pos) LOG_INF("<<<");
+    }
+    LOG_INF("\n=== END POSITION ===\n");
+}
+
+static void common_chat_parse_glm_4_5(common_chat_msg_parser & builder) {
+    debug_print_raw_input(builder.input());
+
+    // Helper function to get expected type from tool schema
+    auto get_expected_type = [&](const std::string& tool_name, const std::string& param_name) -> std::string {
+        // Access tools schema from builder syntax
+        const auto& tools_schema = builder.syntax().tools_schema;
+        if (tools_schema.is_array()) {
+            for (const auto& tool : tools_schema) {
+                if (tool.contains("function") && tool["function"]["name"] == tool_name) {
+                    auto params = tool["function"]["parameters"];
+                    if (params.contains("properties") && params["properties"].contains(param_name)) {
+                        return params["properties"][param_name].value("type", "string");
+                    }
+                }
+            }
+        }
+        return "string"; // Default fallback
+    };
 
-    while (auto res = builder.try_find_regex(tool_call_start)) {
-        // Move to the start of the tool call and consume it
-        builder.move_to(res->groups[0].begin);
-        builder.consume_regex(tool_call_start);
+    auto handle_tool_call_end = [&] (common_chat_msg_parser & builder, auto end_pos) {
+        builder.move_to(end_pos);
+        builder.consume_literal("</tool_call>");
 
-        std::string function_name = builder.str(res->groups[1]);
-        json arguments = json::object();
+        size_t obs_pos = builder.input().find("<|observation|>", builder.pos());
+        if (obs_pos != std::string::npos) {
+            if (obs_pos > builder.pos()) {
+                std::string content = builder.input().substr(builder.pos(), obs_pos - builder.pos());
+                builder.add_content(content);
+            }
+            
+            builder.move_to(obs_pos);
+            builder.consume_literal("<|observation|>");
+        } else {
+            std::string remaining = builder.consume_rest();
+            if (!remaining.empty()) builder.add_content(remaining);
+        }
+    };
+
+    builder.consume_spaces();
+    
+    builder.try_parse_reasoning("<think>", "</think>");
+    
+    size_t curr_pos = builder.pos();
+    while (builder.input().find("<tool_call>", builder.pos()) != std::string::npos) {
+        size_t tool_call_start = builder.input().find("<tool_call>", builder.pos());
+        if (tool_call_start > builder.pos()) {
+            std::string content = builder.input().substr(builder.pos(), tool_call_start - builder.pos());
+            builder.add_content(content);
+        }
 
+        size_t tool_call_end = builder.input().find("</tool_call>", tool_call_start);
+        if (tool_call_end == std::string::npos) return;
+
+        builder.move_to(tool_call_start);
+        builder.consume_literal("<tool_call>");
         builder.consume_spaces();
-        
-        // Parse all arg_key/arg_value pairs
-        while (auto key_res = builder.try_consume_regex(arg_key_regex)) {
-            std::string key = builder.str(key_res->groups[1]);
-            builder.consume_spaces();
+
+        size_t arg_key_start = builder.input().find("<arg_key>", tool_call_start);
+        if (arg_key_start == std::string::npos) {
+            std::string function_content = builder.input().substr(builder.pos(), tool_call_end - builder.pos());
+            std::string function_name = string_strip(function_content);
+            
+            if (!builder.add_tool_call(function_name, "", "{}")) {
+                LOG_INF("%s: failed to add tool call\n", __func__);
+            }
+
+            handle_tool_call_end(builder, tool_call_end);
+
+        } else {
+            std::string function_content = builder.input().substr(builder.pos(), arg_key_start - builder.pos());
+            std::string function_name = string_strip(function_content);
+            
+            json args_json = json::object();
+            builder.move_to(arg_key_start);
 
-            if (auto value_res = builder.try_consume_regex(arg_value_regex)) {
-                std::string value = builder.str(value_res->groups[1]);
-                arguments[key] = value;
+            while (builder.pos() < tool_call_end) {
+                if (!builder.try_consume_literal("<arg_key>")) {
+                    builder.consume_spaces();
+                    if (!builder.try_consume_literal("<arg_key>")) {
+                        break;
+                    }
+                }
+                
+                auto key_close = builder.try_find_literal("</arg_key>");
+                if (!key_close || key_close->groups[0].end > tool_call_end) {
+                    throw common_chat_msg_partial_exception("incomplete tool call");
+                    return;
+                }
+                
+                std::string key = string_strip(key_close->prelude);
+                
                 builder.consume_spaces();
+                
+                if (!builder.try_consume_literal("<arg_value>")) {
+                    throw common_chat_msg_partial_exception("incomplete tool call");
+                    return;
+                }
+                
+                auto value_close = builder.try_find_literal("</arg_value>");
+                if (!value_close || value_close->groups[0].end > tool_call_end) {
+                    throw common_chat_msg_partial_exception("incomplete tool call");
+                    return;
+                }
+                
+                std::string value = string_strip(value_close->prelude);
+
+                // Schema-aware type conversion
+                std::string expected_type = get_expected_type(function_name, key);
+                json parsed_value;
+
+                if (expected_type == "integer" || expected_type == "number") {
+                    try {
+                        parsed_value = std::stod(value); // or std::stoi for integers
+                    } catch (...) {
+                        parsed_value = value; // Fallback to string
+                    }
+                } else if (expected_type == "boolean") {
+                    parsed_value = (value == "true");
+                } else if (expected_type == "array" || expected_type == "object") {
+                    try {
+                        parsed_value = json::parse(value);
+                    } catch (...) {
+                        parsed_value = value;
+                    }
+                } else {
+                    // Default to string
+                    parsed_value = value;
+                }
+
+                args_json[key] = parsed_value;
+
+                builder.consume_spaces();
+            }
+            
+            if (!builder.add_tool_call(function_name, "", args_json.dump())) {
+                LOG_INF("%s: failed to add tool call with arguments\n", __func__);
             } else {
-                throw common_chat_msg_partial_exception("Expected <arg_value> after <arg_key>");
+                LOG_INF("%s: successfully added tool call with arguments\n", __func__);
             }
+
+            handle_tool_call_end(builder, tool_call_end);
         }
-        
-        // Consume closing tag
-        builder.consume_regex(tool_call_end);
-        builder.consume_spaces();
-        
-        // Add the parsed tool call
-        if (!builder.add_tool_call(function_name, "", arguments.dump())) {
-            throw common_chat_msg_partial_exception("Failed to add GLM tool call");
+    
+        if (curr_pos == builder.pos()) {
+            // No progress made, avoid infinite loop
+            LOG_INF("%s: no progress in parsing, stopping to avoid infinite loop\n", __func__);
+            break;
         }
     }
 
-    builder.add_content(builder.consume_rest());
+    if (builder.pos() < builder.input().size()) {
+        builder.add_content(builder.consume_rest());
+    }
 }
 
+
 static common_chat_params common_chat_params_init_firefunction_v2(const common_chat_template & tmpl, const struct templates_params & inputs) {
     LOG_DBG("%s\n", __func__);
     common_chat_params data;

common/chat.cpp

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "common.h"
+#include <nlohmann/json.hpp>
 #include <functional>
 #include <chrono>
 #include <string>
@@ -142,6 +143,7 @@ struct common_chat_params {
     std::vector<common_grammar_trigger> grammar_triggers;
     std::vector<std::string>            preserved_tokens;
     std::vector<std::string>            additional_stops;
+    nlohmann::ordered_json              tools_schema = nlohmann::ordered_json();  // Schema for tools to pass to parser
 };
 
 struct common_chat_syntax {
@@ -151,6 +153,7 @@ struct common_chat_syntax {
     bool                     reasoning_in_content  = false;
     bool                     thinking_forced_open  = false;
     bool                     parse_tool_calls      = true;
+    nlohmann::ordered_json   tools_schema          = nlohmann::ordered_json();  // Schema for tools to enable type-aware parsing
 };
 
 // Check if the template supplied via "--chat-template" is supported or not. Returns true if it's valid