server: GLM tool-call parser stringifies all argument values (numbers/arrays become strings), breaking schema-validating clients

[solodddd]

Branch: glm5.2 (bd89932, also present at the current branch tip) Model: GLM 5.2 Component: ds4_server.c, OpenAI-compatible /v1/chat/completions tool calling

Summary
On the glm5.2 branch, the GLM tool-call parser emits every tool argument as a JSON string, regardless of its actual type. Numbers become "10", arrays become "[]", booleans become "true". Any client that validates tool-call arguments against the tool's JSON schema (Chatwise, and generally anything using zod/ajv-style validation) rejects the call.

Reproduction
curl -s http://localhost:18004/v1/chat/completions -H "Content-Type: application/json" -d '{
"model": "glm-5.2-chat",
"messages": [{"role":"user","content":"Search the web for ByteDance inference chips, return 10 results"}],
"tools": [{
"type": "function",
"function": {
"name": "WebSearch",
"description": "Search the web",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string"},
"max_results": {"type": "number"},
"exclude_domains": {"type": "array", "items": {"type": "string"}}
},
"required": ["query"]
}
}
}]
}'
Actual (note max_results is a string):

"function": {
"name": "WebSearch",
"arguments": "{"query":"ByteDance inference chips","max_results":"10"}"
}
Expected:

"arguments": "{"query":"ByteDance inference chips","max_results":10}"
Client-side symptom (Chatwise, zod validation):

Invalid input for tool WebSearch: Type validation failed:
Value: {"query":"...","exclude_domains":"[]","max_results":"10"}
[{ "expected": "number", "code": "invalid_type", "path": ["max_results"] }]
Root cause
In parse_glm_generated_message_ex (ds4_server.c:5049), every <arg_value> is added with is_string hardcoded to "true":

tool_call_json_args_add(&args, key, value, "true");
GLM's wire format (<arg_key>name</arg_key><arg_value>10</arg_value>) carries no type information — unlike DeepSeek's DSML, which has the string="true|false" attribute that the DSML path already honors. So the GLM path JSON-escapes everything into a string.

Possible fixes
Heuristic (self-contained): try to parse the raw <arg_value> text as a JSON scalar/array/object (number, true/false/null, [...], {...}); if it parses, emit it raw (the existing json_minify_raw_value path, i.e. is_string = "false"), otherwise emit a string. This mirrors what most GLM tool parsers do.
Schema-aware (precise): look up the parameter's declared type in the request's tools[].function.parameters and coerce accordingly (what vLLM's GLM tool parser does). More work, since the server currently doesn't consult client tool schemas at parse time.
Happy to test a patch — I can reproduce this reliably.

[5rrjb76mcm-lgtm]

Confirming this on the laguna-s2.1 branch as well — Laguna S 2.1 is affected identically, because append_laguna_tool_calls_text (ds4_server.c:2420) delegates to the GLM helpers, so Laguna goes through the same parse_glm_generated_message_ex path. Your ds4_server.c:5049 is 5259 at bf605b1.

Setup: Metal, M5 Max 128 GB, laguna-s-2.1-Q4_K_M.gguf (official Poolside imatrix) + DFlash.

With the real schema from @cyanheads/pubmed-mcp-server, 3 runs out of 3:

{"query": "coronary stent thrombosis", "maxResults": "10", "summaryCount": "10"}

Sent to the actual MCP server over stdio, this is a hard rejection, no coercion:

MCP error -32602: Input validation error: Invalid arguments for tool pubmed_search_articles:
[{ "expected": "number", "code": "invalid_type", "path": ["maxResults"],
   "message": "Invalid input: expected number, received string" }]

So on the Laguna branch this makes every typed MCP tool unusable, not just numeric-arg web search.

---

I implemented your option 2 (schema-aware) and it turned out to be much less work than expected — the server does already have the client tool schemas at parse time, it just never passes them down. request carries tool_orders, and tool_schema_orders already reaches the render side; only the parser is cut off from it.

1. Add prop_type[] to tool_schema_order, parallel to prop[], filled in parse_schema_properties. A union such as ["integer","null"] takes the first non-null entry.
2. New tool_schema_arg_is_string() — quotes only when the declared type is "string". Unknown tools and undeclared properties keep today's string-only behaviour, so absent schemas change nothing.
3. parse_glm_generated_message_ex() gains a trailing const tool_schema_orders *orders. parse_generated_message_ex_for_syntax() and parse_generated_message_for_response_for_syntax() are kept as thin wrappers delegating with NULL, so the ~25 existing test call sites stay untouched; _orders variants carry the schemas.
4. The two production call sites pass &j->req.tool_orders.

I deliberately avoided option 1 (heuristic): parsing the raw <arg_value> text opportunistically corrupts a genuine string "10", "true", or "[1,2]", and there is no way for the model to escape out of it. The schema declaration is the only safe input. Worth noting that vLLM's GLM parser is schema-aware for the same reason.

Testing on laguna-s2.1 @ bf605b1:

• Builds warning-free.
• ./ds4_test reports 29 failures both with and without the patch — all in tests/ds4_test.c engine-level checks (tensor equivalence, tokenizer), unrelated and pre-existing. No regression.
• ./ds4_test --server passes.
• New test_glm_tool_call_restores_schema_types covers string / integer / boolean / array / union / undeclared, plus the orders == NULL path asserting the old behaviour is retained. I verified the test actually runs by mutating an expected value and watching it fail.
• End to end: Laguna → patched ds4 → real @cyanheads/pubmed-mcp-server over stdio → accepted, 10 PMIDs returned.

After the patch, same request, 3 runs out of 3:

{"query": "coronary stent thrombosis", "maxResults": 10, "summaryCount": 10}

Diff below (ds4_server.c only, +221/-30). It applies to laguna-s2.1; the same change should work on glm5.2 since the affected functions are shared, though I have no GLM weights locally to verify that. Glad to turn this into a PR against whichever branch you prefer.

Full diff against bf605b1

diff --git a/ds4_server.c b/ds4_server.c
index c2ada7a..9a5f182 100644
--- a/ds4_server.c
+++ b/ds4_server.c
@@ -560,6 +560,10 @@ typedef struct {
      * happens to be named "tool_search". */
     bool responses_tool_search;
     char **prop;
+    /* Declared JSON Schema type per property, parallel to prop[].  NULL when
+     * the schema declares none.  Used to restore argument types for the
+     * GLM/Laguna <arg_value> syntax, which carries no type marker itself. */
+    char **prop_type;
     int len;
     int cap;
 } tool_schema_order;
@@ -732,6 +736,10 @@ static void tool_schema_order_free(tool_schema_order *o) {
     free(o->namespace);
     for (int i = 0; i < o->len; i++) free(o->prop[i]);
     free(o->prop);
+    if (o->prop_type) {
+        for (int i = 0; i < o->len; i++) free(o->prop_type[i]);
+        free(o->prop_type);
+    }
     memset(o, 0, sizeof(*o));
 }
 
@@ -741,14 +749,67 @@ static void tool_schema_orders_free(tool_schema_orders *orders) {
     memset(orders, 0, sizeof(*orders));
 }
 
-static void tool_schema_order_prop_push(tool_schema_order *o, char *prop) {
+static void tool_schema_order_prop_push(tool_schema_order *o, char *prop, char *type) {
     if (o->len == o->cap) {
         o->cap = o->cap ? o->cap * 2 : 8;
         o->prop = xrealloc(o->prop, (size_t)o->cap * sizeof(o->prop[0]));
+        o->prop_type = xrealloc(o->prop_type, (size_t)o->cap * sizeof(o->prop_type[0]));
     }
+    o->prop_type[o->len] = type;
     o->prop[o->len++] = prop;
 }
 
+/* Extract the declared "type" of a JSON Schema property object.  Returns a
+ * freshly allocated string, or NULL when absent/uninterpretable.  A union type
+ * such as ["integer","null"] yields the first non-"null" entry. */
+static char *json_schema_declared_type(const char *schema) {
+    if (!schema) return NULL;
+    const char *p = schema;
+    json_ws(&p);
+    if (*p != '{') return NULL;
+    p++;
+    json_ws(&p);
+    while (*p && *p != '}') {
+        char *key = NULL;
+        if (!json_string(&p, &key)) return NULL;
+        json_ws(&p);
+        if (*p != ':') {
+            free(key);
+            return NULL;
+        }
+        p++;
+        bool want = !strcmp(key, "type");
+        free(key);
+        if (want) {
+            json_ws(&p);
+            if (*p == '"') {
+                char *t = NULL;
+                return json_string(&p, &t) ? t : NULL;
+            }
+            if (*p == '[') {
+                p++;
+                json_ws(&p);
+                while (*p && *p != ']') {
+                    char *t = NULL;
+                    if (!json_string(&p, &t)) return NULL;
+                    if (strcmp(t, "null") != 0) return t;
+                    free(t);
+                    json_ws(&p);
+                    if (*p == ',') p++;
+                    json_ws(&p);
+                }
+                return NULL;
+            }
+            return NULL;
+        }
+        if (!json_skip_value(&p)) return NULL;
+        json_ws(&p);
+        if (*p == ',') p++;
+        json_ws(&p);
+    }
+    return NULL;
+}
+
 static int tool_schema_orders_find_index(const tool_schema_orders *orders, const char *name) {
     if (!orders || !name) return -1;
     for (int i = 0; i < orders->len; i++) {
@@ -776,6 +837,23 @@ static const tool_schema_order *tool_schema_orders_find(const tool_schema_orders
     return idx >= 0 ? &orders->v[idx] : NULL;
 }
 
+/* "true" when an argument must be emitted as a JSON string, "false" when the
+ * tool schema declares a non-string type.  Unknown tools and undeclared
+ * properties keep the historical string-only behaviour. */
+static const char *tool_schema_arg_is_string(const tool_schema_orders *orders,
+                                             const char *tool, const char *key) {
+    const tool_schema_order *o = tool_schema_orders_find(orders, tool);
+    if (!o || !o->prop_type || !key) return "true";
+    for (int i = 0; i < o->len; i++) {
+        if (o->prop[i] && !strcmp(o->prop[i], key)) {
+            const char *t = o->prop_type[i];
+            if (!t) return "true";
+            return strcmp(t, "string") ? "false" : "true";
+        }
+    }
+    return "true";
+}
+
 static void request_init(request *r, req_kind kind, int max_tokens) {
     memset(r, 0, sizeof(*r));
     r->kind = kind;
@@ -1459,8 +1537,14 @@ static bool parse_schema_properties(const char *json, tool_schema_order *order)
                     return false;
                 }
                 p++;
-                tool_schema_order_prop_push(order, prop);
-                if (!json_skip_value(&p)) return false;
+                char *prop_schema = NULL;
+                if (!json_raw_value(&p, &prop_schema)) {
+                    free(prop);
+                    return false;
+                }
+                tool_schema_order_prop_push(order, prop,
+                                            json_schema_declared_type(prop_schema));
+                free(prop_schema);
                 json_ws(&p);
                 if (*p == ',') p++;
                 json_ws(&p);
@@ -5162,7 +5246,8 @@ static bool parse_glm_generated_message_ex(const char *text,
                                            bool require_thinking_closed,
                                            char **content_out,
                                            char **reasoning_out,
-                                           tool_calls *calls) {
+                                           tool_calls *calls,
+                                           const tool_schema_orders *orders) {
     static const char tool_start[] = "<tool_call>";
     static const char tool_end[] = "</tool_call>";
     static const char arg_key_start[] = "<arg_key>";
@@ -5256,7 +5341,11 @@ static bool parse_glm_generated_message_ex(const char *text,
             }
             char *raw_value = xstrndup(p, (size_t)(value_end - p));
             char *value = dsml_unescape_text(raw_value);
-            tool_call_json_args_add(&args, key, value, "true");
+            /* <arg_value> carries no type marker, unlike DSML's
+             * string="true|false".  Recover the type from the tool schema so
+             * numbers, booleans, arrays and objects are not stringified. */
+            tool_call_json_args_add(&args, key, value,
+                                    tool_schema_arg_is_string(orders, name, key));
             free(key);
             free(raw_value);
             free(value);
@@ -5288,23 +5377,36 @@ static bool parse_glm_generated_message_ex(const char *text,
     return true;
 }
 
-static bool parse_generated_message_ex_for_syntax(server_model_syntax syntax,
-                                                  const char *text,
-                                                  bool require_thinking_closed,
-                                                  char **content_out,
-                                                  char **reasoning_out,
-                                                  tool_calls *calls) {
+static bool parse_generated_message_ex_for_syntax_orders(server_model_syntax syntax,
+                                                         const char *text,
+                                                         bool require_thinking_closed,
+                                                         char **content_out,
+                                                         char **reasoning_out,
+                                                         tool_calls *calls,
+                                                         const tool_schema_orders *orders) {
     if (syntax == SERVER_MODEL_SYNTAX_GLM ||
         syntax == SERVER_MODEL_SYNTAX_LAGUNA) {
         return parse_glm_generated_message_ex(text, require_thinking_closed,
                                               content_out, reasoning_out,
-                                              calls);
+                                              calls, orders);
     }
     return parse_deepseek_generated_message_ex(text, require_thinking_closed,
                                                content_out, reasoning_out,
                                                calls);
 }
 
+static bool parse_generated_message_ex_for_syntax(server_model_syntax syntax,
+                                                  const char *text,
+                                                  bool require_thinking_closed,
+                                                  char **content_out,
+                                                  char **reasoning_out,
+                                                  tool_calls *calls) {
+    return parse_generated_message_ex_for_syntax_orders(syntax, text,
+                                                        require_thinking_closed,
+                                                        content_out, reasoning_out,
+                                                        calls, NULL);
+}
+
 static DS4_SERVER_MAYBE_UNUSED bool parse_generated_message_ex(
         const char *text,
         bool require_thinking_closed,
@@ -5392,26 +5494,29 @@ static const char *tool_parse_failure_recovery_finish(const char *finish) {
     return "stop";
 }
 
-static bool parse_generated_message_for_response_for_syntax(server_model_syntax syntax,
-                                                            const char *text,
-                                                            bool has_tools,
-                                                            bool saw_tool_start,
-                                                            bool require_thinking_closed,
-                                                            const char **finish_io,
-                                                            char *err,
-                                                            size_t errlen,
-                                                            char **content_out,
-                                                            char **reasoning_out,
-                                                            tool_calls *calls,
-                                                            bool *recovered_out) {
+static bool parse_generated_message_for_response_for_syntax_orders(
+        server_model_syntax syntax,
+        const char *text,
+        bool has_tools,
+        bool saw_tool_start,
+        bool require_thinking_closed,
+        const char **finish_io,
+        char *err,
+        size_t errlen,
+        char **content_out,
+        char **reasoning_out,
+        tool_calls *calls,
+        bool *recovered_out,
+        const tool_schema_orders *orders) {
     if (recovered_out) *recovered_out = false;
 
-    bool parsed_ok = parse_generated_message_ex_for_syntax(syntax,
+    bool parsed_ok = parse_generated_message_ex_for_syntax_orders(syntax,
                                                            text ? text : "",
                                                            require_thinking_closed,
                                                            content_out,
                                                            reasoning_out,
-                                                           calls);
+                                                           calls,
+                                                           orders);
     if (parsed_ok) return true;
 
     free(*content_out);
@@ -5434,6 +5539,24 @@ static bool parse_generated_message_for_response_for_syntax(server_model_syntax
     return false;
 }
 
+static bool parse_generated_message_for_response_for_syntax(server_model_syntax syntax,
+                                                            const char *text,
+                                                            bool has_tools,
+                                                            bool saw_tool_start,
+                                                            bool require_thinking_closed,
+                                                            const char **finish_io,
+                                                            char *err,
+                                                            size_t errlen,
+                                                            char **content_out,
+                                                            char **reasoning_out,
+                                                            tool_calls *calls,
+                                                            bool *recovered_out) {
+    return parse_generated_message_for_response_for_syntax_orders(
+        syntax, text, has_tools, saw_tool_start, require_thinking_closed,
+        finish_io, err, errlen, content_out, reasoning_out, calls,
+        recovered_out, NULL);
+}
+
 static DS4_SERVER_MAYBE_UNUSED bool parse_generated_message_for_response(
         const char *text,
         bool has_tools,
@@ -11893,9 +12016,10 @@ decode_again:
             tool_calls test_calls = {0};
             char *test_content = NULL;
             char *test_reasoning = NULL;
-            bool repair_ok = parse_generated_message_ex_for_syntax(
+            bool repair_ok = parse_generated_message_ex_for_syntax_orders(
                 j->req.model_syntax, repaired.ptr, false,
-                &test_content, &test_reasoning, &test_calls);
+                &test_content, &test_reasoning, &test_calls,
+                &j->req.tool_orders);
             free(test_content);
             free(test_reasoning);
             if (repair_ok && test_calls.len > 0) {
@@ -11981,7 +12105,7 @@ decode_again:
     const char *final_finish = finish;
     bool recovered_tool_parse_failure = false;
     if (j->req.kind == REQ_CHAT) {
-        bool parsed_ok = parse_generated_message_for_response_for_syntax(
+        bool parsed_ok = parse_generated_message_for_response_for_syntax_orders(
             j->req.model_syntax,
             text.ptr ? text.ptr : "",
             j->req.has_tools,
@@ -11993,7 +12117,8 @@ decode_again:
             &parsed_content,
             &parsed_reasoning,
             &parsed_calls,
-            &recovered_tool_parse_failure);
+            &recovered_tool_parse_failure,
+            &j->req.tool_orders);
         if (!parsed_ok && recovered_tool_parse_failure && j->req.has_tools && saw_tool_start) {
             /* parse_generated_message failed even though DSML was present.
              * Semantic repair is intentionally avoided: if the parser cannot
@@ -15184,6 +15309,71 @@ static void test_parse_glm_tool_call_message(void) {
     tool_calls_free(&calls);
 }
 
+/* <arg_value> carries no type marker.  With the tool schema available the
+ * parser must restore declared non-string types instead of quoting everything,
+ * otherwise strict MCP servers reject the call with "expected number,
+ * received string". */
+static void test_glm_tool_call_restores_schema_types(void) {
+    tool_schema_orders orders = {0};
+    tool_schema_orders_add_json(&orders,
+        "{\"name\":\"search\",\"parameters\":{\"type\":\"object\",\"properties\":{"
+        "\"query\":{\"type\":\"string\"},"
+        "\"maxResults\":{\"default\":20,\"type\":\"integer\",\"minimum\":1},"
+        "\"verbose\":{\"type\":\"boolean\"},"
+        "\"pmids\":{\"type\":\"array\",\"items\":{\"type\":\"string\"}},"
+        "\"offset\":{\"type\":[\"integer\",\"null\"]},"
+        "\"note\":{\"description\":\"no declared type\"}}}}");
+
+    const tool_schema_order *order = tool_schema_orders_find(&orders, "search");
+    TEST_ASSERT(order && order->len == 6);
+    TEST_ASSERT(order->prop_type[0] && !strcmp(order->prop_type[0], "string"));
+    TEST_ASSERT(order->prop_type[1] && !strcmp(order->prop_type[1], "integer"));
+    TEST_ASSERT(order->prop_type[4] && !strcmp(order->prop_type[4], "integer"));
+    TEST_ASSERT(order->prop_type[5] == NULL);
+
+    const char *generated =
+        "</think>Searching"
+        "<tool_call>search"
+        "<arg_key>query</arg_key><arg_value>stent thrombosis</arg_value>"
+        "<arg_key>maxResults</arg_key><arg_value>10</arg_value>"
+        "<arg_key>verbose</arg_key><arg_value>true</arg_value>"
+        "<arg_key>pmids</arg_key><arg_value>[\"1\",\"2\"]</arg_value>"
+        "<arg_key>offset</arg_key><arg_value>0</arg_value>"
+        "<arg_key>note</arg_key><arg_value>10</arg_value>"
+        "</tool_call>";
+    char *content = NULL;
+    char *reasoning = NULL;
+    tool_calls calls = {0};
+    TEST_ASSERT(parse_generated_message_ex_for_syntax_orders(
+        SERVER_MODEL_SYNTAX_LAGUNA, generated, true,
+        &content, &reasoning, &calls, &orders));
+    TEST_ASSERT(calls.len == 1);
+    const char *a = calls.v[0].arguments;
+    TEST_ASSERT(strstr(a, "\"query\": \"stent thrombosis\"") != NULL);
+    TEST_ASSERT(strstr(a, "\"maxResults\": 10") != NULL);
+    TEST_ASSERT(strstr(a, "\"verbose\": true") != NULL);
+    TEST_ASSERT(strstr(a, "\"pmids\": [\"1\",\"2\"]") != NULL);
+    TEST_ASSERT(strstr(a, "\"offset\": 0") != NULL);
+    /* Undeclared property keeps the historical string behaviour. */
+    TEST_ASSERT(strstr(a, "\"note\": \"10\"") != NULL);
+
+    free(content);
+    free(reasoning);
+    tool_calls_free(&calls);
+    tool_schema_orders_free(&orders);
+
+    /* Without schemas nothing changes: every argument stays a string. */
+    char *c2 = NULL, *r2 = NULL;
+    tool_calls calls2 = {0};
+    TEST_ASSERT(parse_generated_message_ex_for_syntax(
+        SERVER_MODEL_SYNTAX_LAGUNA, generated, true, &c2, &r2, &calls2));
+    TEST_ASSERT(calls2.len == 1);
+    TEST_ASSERT(strstr(calls2.v[0].arguments, "\"maxResults\": \"10\"") != NULL);
+    free(c2);
+    free(r2);
+    tool_calls_free(&calls2);
+}
+
 static void test_dsml_parser_recovers_loose_nested_parameters(void) {
     const char *generated =
         "review done\n\n"
@@ -17839,6 +18029,7 @@ static void ds4_server_unit_tests_run(void) {
     test_streaming_holds_partial_utf8();
     test_parse_short_dsml_and_canonical_suffix();
     test_parse_glm_tool_call_message();
+    test_glm_tool_call_restores_schema_types();
     test_dsml_parser_recovers_loose_nested_parameters();
     test_dsml_repair_produces_parseable_calls();
     test_tool_parse_failure_returns_recoverable_finish();