Keep prose tool-tag mentions in GLM answers as text

GLM's argument-tag parser had the same defect in answer text: any `<tool_call>`
after `</think>` started a call. A quoted tag in prose aborted the response at
EOS with "incomplete GLM tool call", and a quoted tag followed by a real call
cut the answer short and returned a call whose function name was the
intervening prose. Reasoning was unaffected because GLM's `<tool_call>` does not
end reasoning.

ArgumentTags now implements ToolDialect::starts_call: `<tool_call>` starts a
call only when followed by a function name and then `<arg_key>` or
`</tool_call>`, matching the GLM 5.3 chat template. Other text keeps the tag in
the answer, and an unresolved prefix is held until later tokens decide. An
undecided tag at finish is still parsed as a call, so truncated calls keep
their EOS error and output-limit handling. This applies to the glm53 recipe;
there is no Protobuf or package change.

Validation: rebased onto bce032c and rerun on a 32-core build host. Helios
library suite for this commit: 1213 passed, 21 ignored, 5 failed, the same five
that fail on unmodified main (four engram::reader staging ENOMEM on that host,
and a package cache test that cannot fail when the suite runs as root). The new
test covers a quoted answer mention, unconfirmed and partial inline tags, and a
mention followed by a real call at every two-way split point, and rustfmt
--check reports no difference in the file. A probe on the unchanged parser
reproduced the abort and the misnamed call for these inputs.

Limitations: not run against GLM output or a live Flare service; Helios
integration tests, Heliopause, Python, and CUDA tests were not run. A complete
call example in prose still parses as a call.

Design-Signed-Off-By: mark-yong (AI-assisted Cursor and DeepSeek-V4.1-Flash review); design-review=babb

Author: mark-yong

helios/src/output/argument_tags.rs

@@ -64,6 +64,32 @@ impl ToolDialect for ArgumentTags {
             })?,
         )])
     }
+    fn starts_call(text: &str) -> Option<bool> {
+        // Calls continue with the function name and an argument key or closing tag;
+        // quoted tags followed by prose remain text.
+        let text = text.strip_prefix(Self::OPEN).unwrap_or(text).trim_start();
+        if text.is_empty() {
+            return None;
+        }
+        let end = text.find(|c: char| c == '<' || c == '>' || c.is_whitespace())?;
+        if end == 0 {
+            return Some(false);
+        }
+        let next = text[end..].trim_start();
+        if ["<arg_key>", "</tool_call>"]
+            .iter()
+            .any(|tag| next.starts_with(tag))
+        {
+            Some(true)
+        } else if ["<arg_key>", "</tool_call>"]
+            .iter()
+            .any(|tag| tag.starts_with(next))
+        {
+            None
+        } else {
+            Some(false)
+        }
+    }
 }
 
 #[cfg(test)]
@@ -143,6 +169,52 @@ mod tests {
         }
     }
 
+    #[test]
+    fn prose_tool_tag_mentions_remain_answer_text() {
+        let call = "<tool_call>run<arg_key>text</arg_key><arg_value>x</arg_value></tool_call>";
+        for (text, content, calls) in [
+            (
+                "</think>The `<tool_call>` tag wraps calls. END".to_owned(),
+                "The `<tool_call>` tag wraps calls. END",
+                0,
+            ),
+            (
+                "</think>Write <tool_call> or `<tool_call>run` literally.".to_owned(),
+                "Write <tool_call> or `<tool_call>run` literally.",
+                0,
+            ),
+            (
+                format!("</think>Quote `<tool_call>` here.\n{call}"),
+                "Quote `<tool_call>` here.\n",
+                1,
+            ),
+        ] {
+            for split in text.char_indices().map(|(at, _)| at) {
+                let mut parser = ArgumentTagOutput::new(config());
+                let mut output = Accumulator::new("test".into());
+                for part in [&text[..split], &text[split..]] {
+                    output
+                        .apply(parser.push(Input::Text(part)).unwrap())
+                        .unwrap();
+                }
+                output
+                    .apply(parser.finish(Termination::Eos).unwrap())
+                    .unwrap();
+                output.finish().unwrap();
+                let message = output.message();
+                assert_eq!(message["content"], content, "{text:?} at {split}");
+                let tools = message["tool_calls"]
+                    .as_array()
+                    .map_or(&[][..], Vec::as_slice);
+                assert_eq!(tools.len(), calls, "{text:?} at {split}");
+                if let Some(tool) = tools.first() {
+                    assert_eq!(tool["function"]["name"], "run");
+                    assert_eq!(tool["function"]["arguments"], "{\"text\":\"x\"}");
+                }
+            }
+        }
+    }
+
     #[test]
     fn truncation_and_structured_output_keep_protocol_semantics() {
         let mut parser = ArgumentTagOutput::new(config());