agent-tool-parser 0.1.4__tar.gz → 0.1.6__tar.gz

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "agent-tool-parser-c"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "agent-tool-parser-core",
  "serde_json",
@@ -12,7 +12,7 @@ dependencies = [
 
 [[package]]
 name = "agent-tool-parser-core"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "html-escape",
  "memchr",
@@ -24,7 +24,7 @@ dependencies = [
 
 [[package]]
 name = "agent-tool-parser-py"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "agent-tool-parser-core",
  "pyo3",
@@ -34,7 +34,7 @@ dependencies = [
 
 [[package]]
 name = "agent-tool-parser-wasm"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "agent-tool-parser-core",
  "serde-wasm-bindgen",

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/agent-tool-parser-core", "crates/agent-tool-parser-py"]
 
 [workspace.package]
-version = "0.1.4"
+version = "0.1.6"
 edition = "2021"
 authors = ["InBoost Team"]
 license = "MIT"

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-tool-parser
-Version: 0.1.4
+Version: 0.1.6
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -41,9 +41,9 @@ Project-URL: Repository, https://github.com/inboost-dev/agent-tool-parser.git
 # agent-tool-parser ⚡
 
 [![Documentation](https://img.shields.io/badge/docs-interactive%20playground-blueviolet.svg)](https://inboost-dev.github.io/agent-tool-parser/)
-[![PyPI version](https://img.shields.io/badge/pypi-v0.1.4-blue.svg)](https://pypi.org/project/agent-tool-parser/)
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.6-blue.svg)](https://pypi.org/project/agent-tool-parser/)
 [![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://pypi.org/)
-[![Crates.io](https://img.shields.io/badge/crates.io-v0.1.4-orange.svg)](https://crates.io/crates/agent-tool-parser-core)
+[![Crates.io](https://img.shields.io/badge/crates.io-v0.1.6-orange.svg)](https://crates.io/crates/agent-tool-parser-core)
 [![Rust](https://img.shields.io/badge/rust-1.75%2B-red.svg)](https://www.rust-lang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen.svg)]()
@@ -421,6 +421,8 @@ agent-tool-parser/
 | :--- | :--- | :---: |
 | **Anthropic Claude XML** | `<tool_use><name>read_file</name><arguments>{"path": "src/core.py"}</arguments></tool_use>` | Supported |
 | **OpenAI Function Format** | `{"tool_calls": [{"type": "function", "function": {"name": "search", "arguments": "{...}"}}]}` | Supported |
+| **Qwen / Open-Weights XML** | `<function=search>\n<parameter=query>vector</parameter>\n</function>` | Supported |
+| **Container Tag Wrappers** | `<tool_call><function=search>...</function></tool_call>` | Supported |
 | **DeepSeek Native Tokens** | `<｜tool call begin｜>function=bash<｜tool sep｜>{"command": "pytest"}<｜tool call end｜>` | Supported |
 | **DeepSeek DSML** | `<｜DSML｜tool name=search><｜DSML｜parameter name=query>vector</｜DSML｜parameter>` | Supported |
 | **Qwen-Agent Tokens** | `<\|action_start\|><\|action_name\|>run<\|action_args\|>{"script": "main.py"}<\|action_end\|>` | Supported |

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/README.md

@@ -1,9 +1,9 @@
 # agent-tool-parser ⚡
 
 [![Documentation](https://img.shields.io/badge/docs-interactive%20playground-blueviolet.svg)](https://inboost-dev.github.io/agent-tool-parser/)
-[![PyPI version](https://img.shields.io/badge/pypi-v0.1.4-blue.svg)](https://pypi.org/project/agent-tool-parser/)
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.6-blue.svg)](https://pypi.org/project/agent-tool-parser/)
 [![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://pypi.org/)
-[![Crates.io](https://img.shields.io/badge/crates.io-v0.1.4-orange.svg)](https://crates.io/crates/agent-tool-parser-core)
+[![Crates.io](https://img.shields.io/badge/crates.io-v0.1.6-orange.svg)](https://crates.io/crates/agent-tool-parser-core)
 [![Rust](https://img.shields.io/badge/rust-1.75%2B-red.svg)](https://www.rust-lang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen.svg)]()
@@ -381,6 +381,8 @@ agent-tool-parser/
 | :--- | :--- | :---: |
 | **Anthropic Claude XML** | `<tool_use><name>read_file</name><arguments>{"path": "src/core.py"}</arguments></tool_use>` | Supported |
 | **OpenAI Function Format** | `{"tool_calls": [{"type": "function", "function": {"name": "search", "arguments": "{...}"}}]}` | Supported |
+| **Qwen / Open-Weights XML** | `<function=search>\n<parameter=query>vector</parameter>\n</function>` | Supported |
+| **Container Tag Wrappers** | `<tool_call><function=search>...</function></tool_call>` | Supported |
 | **DeepSeek Native Tokens** | `<｜tool call begin｜>function=bash<｜tool sep｜>{"command": "pytest"}<｜tool call end｜>` | Supported |
 | **DeepSeek DSML** | `<｜DSML｜tool name=search><｜DSML｜parameter name=query>vector</｜DSML｜parameter>` | Supported |
 | **Qwen-Agent Tokens** | `<\|action_start\|><\|action_name\|>run<\|action_args\|>{"script": "main.py"}<\|action_end\|>` | Supported |

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/crates/agent-tool-parser-core/README.md

@@ -1,9 +1,9 @@
 # agent-tool-parser ⚡
 
 [![Documentation](https://img.shields.io/badge/docs-interactive%20playground-blueviolet.svg)](https://inboost-dev.github.io/agent-tool-parser/)
-[![PyPI version](https://img.shields.io/badge/pypi-v0.1.4-blue.svg)](https://pypi.org/project/agent-tool-parser/)
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.6-blue.svg)](https://pypi.org/project/agent-tool-parser/)
 [![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://pypi.org/)
-[![Crates.io](https://img.shields.io/badge/crates.io-v0.1.4-orange.svg)](https://crates.io/crates/agent-tool-parser-core)
+[![Crates.io](https://img.shields.io/badge/crates.io-v0.1.6-orange.svg)](https://crates.io/crates/agent-tool-parser-core)
 [![Rust](https://img.shields.io/badge/rust-1.75%2B-red.svg)](https://www.rust-lang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen.svg)]()
@@ -381,6 +381,8 @@ agent-tool-parser/
 | :--- | :--- | :---: |
 | **Anthropic Claude XML** | `<tool_use><name>read_file</name><arguments>{"path": "src/core.py"}</arguments></tool_use>` | Supported |
 | **OpenAI Function Format** | `{"tool_calls": [{"type": "function", "function": {"name": "search", "arguments": "{...}"}}]}` | Supported |
+| **Qwen / Open-Weights XML** | `<function=search>\n<parameter=query>vector</parameter>\n</function>` | Supported |
+| **Container Tag Wrappers** | `<tool_call><function=search>...</function></tool_call>` | Supported |
 | **DeepSeek Native Tokens** | `<｜tool call begin｜>function=bash<｜tool sep｜>{"command": "pytest"}<｜tool call end｜>` | Supported |
 | **DeepSeek DSML** | `<｜DSML｜tool name=search><｜DSML｜parameter name=query>vector</｜DSML｜parameter>` | Supported |
 | **Qwen-Agent Tokens** | `<\|action_start\|><\|action_name\|>run<\|action_args\|>{"script": "main.py"}<\|action_end\|>` | Supported |

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/crates/agent-tool-parser-core/src/parser.rs

@@ -13,28 +13,40 @@ static JSON_BLOCK_RE: Lazy<Regex> =
 static JSON_ARRAY_BLOCK_RE: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"(?s)```(?:json)?\s*(\[.*?\])\s*```").unwrap());
 
+/// Safely find the closest char boundary at or below `index` (MSRV 1.75+ compatible).
+#[inline]
+pub(crate) fn floor_char_boundary(s: &str, mut index: usize) -> usize {
+    if index >= s.len() {
+        return s.len();
+    }
+    while !s.is_char_boundary(index) {
+        index -= 1;
+    }
+    index
+}
+
 pub(crate) static INVOKE_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
-        r#"(?is)<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*(?P<colon_tool>[\w-]+))?\b(?P<attrs>[^>]*)>(?P<body>.*?)(?:</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*[\w-]+)?\s*>|<[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)\b|</[｜|]*(?:dsml[｜|]*)?(?:tool_calls|function_calls|calls|tools)\s*>|$)"#
+        r#"(?is)<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*['"]?(?P<colon_tool>[\w.:-]+)['"]?)?\b(?P<attrs>[^>]*)>(?P<body>.*?)(?:</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*[\w.:-]+)?\s*>|<[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)\b|</[｜|]*(?:dsml[｜|]*)?(?:tool_call|tool_calls|function_calls|calls|tools)\s*>|$)"#
     ).unwrap()
 });
 
 static PARAM_START_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
-        r#"(?is)<[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)\b[^>]*?\bname\s*=\s*['"]?(?P<pname>[\w-]+)['"]?[^>]*>"#
+        r#"(?is)<[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)(?:=\s*['"]?(?P<pname_eq>[\w.:-]+)['"]?|\b[^>]*?\bname\s*=\s*['"]?(?P<pname>[\w.:-]+)['"]?)[^>]*>"#
     ).unwrap()
 });
 
 static PARAM_END_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
-        r#"(?is)</[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)\s*>"#,
+        r#"(?is)</[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)(?:(?::|=)\s*[\w.:-]+)?\s*>"#,
     )
     .unwrap()
 });
 
 static INVOKE_END_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
-        r#"(?is)</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*[a-zA-Z0-9_-]+)?\s*>|</[｜|]*(?:dsml[｜|]*)?(?:tool_calls|function_calls|calls|tools)\s*>"#
+        r#"(?is)</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*[a-zA-Z0-9_.:-]+)?\s*>|</[｜|]*(?:dsml[｜|]*)?(?:tool_call|tool_calls|function_calls|calls|tools)\s*>"#
     ).unwrap()
 });
 
@@ -71,7 +83,16 @@ pub(crate) fn extract_xml_parameters(body: &str) -> Vec<(String, String)> {
             {
                 return None;
             }
-            let pname = caps.name("pname").unwrap().as_str().trim().to_lowercase();
+            let pname = if let Some(m) = caps.name("pname") {
+                m.as_str().trim().to_lowercase()
+            } else if let Some(m) = caps.name("pname_eq") {
+                m.as_str().trim().to_lowercase()
+            } else {
+                String::new()
+            };
+            if pname.is_empty() {
+                return None;
+            }
             Some((start, m.end(), pname))
         })
         .collect();
@@ -150,10 +171,17 @@ static ATTRS_NAME_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r#"(?i)\b(?:name|function|tool|action)\s*=\s*['"]?([\w-]+)['"]?"#).unwrap()
 });
 
-static CHILD_TAG_NAME_RE: Lazy<Regex> = Lazy::new(|| {
+pub(crate) static CHILD_TAG_NAME_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r#"(?i)<(?:name|tool_name|function_name|tool|function)>\s*([\w-]+)(?:</(?:name|tool_name|function_name|tool|function)>|\s|$)"#).unwrap()
 });
 
+pub(crate) static CHILD_TAG_FN_EQ_RE: Lazy<Regex> = Lazy::new(|| {
+    Regex::new(r#"(?is)<[｜|]*(?:dsml[｜|]*)?(?:function|tool|invoke|action|func)\s*=\s*['"]?(?P<name>[\w.:-]+)"#).unwrap()
+});
+
+pub(crate) static TOOL_CALL_CONTAINER_RE: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r#"(?is)</?[｜|]*(?:dsml[｜|]*)?tool_call\s*>"#).unwrap());
+
 static ARGUMENTS_BLOCK_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(r#"(?is)<(?:arguments|parameters)>(.*?)(?:</(?:arguments|parameters)>|$)"#).unwrap()
 });
@@ -537,7 +565,8 @@ impl ToolParser {
         Err(ToolError::new(format!(
             "No valid tool call found in response: {:?}",
             if text.len() > 100 {
-                &text[..100]
+                let end = floor_char_boundary(&text, 100);
+                &text[..end]
             } else {
                 &text
             }
@@ -642,6 +671,19 @@ impl ToolParser {
             return Vec::new();
         }
 
+        let lower = text.to_lowercase();
+        let cleaned_buf;
+        let text = if (lower.contains("<tool_call>") || lower.contains("</tool_call>"))
+            && (lower.contains("<function")
+                || lower.contains("<invoke")
+                || lower.contains("<action"))
+        {
+            cleaned_buf = TOOL_CALL_CONTAINER_RE.replace_all(text, "").into_owned();
+            &cleaned_buf
+        } else {
+            text
+        };
+
         let mut calls = Vec::new();
 
         // 1. Direct tag format: <tool_name>search</tool_name><pattern>...</pattern>
@@ -690,15 +732,28 @@ impl ToolParser {
             if tool_name.is_none() {
                 if let Some(caps) = CHILD_TAG_NAME_RE.captures(body) {
                     tool_name = caps.get(1).map(|m| m.as_str().to_string());
+                } else if let Some(caps) = CHILD_TAG_FN_EQ_RE.captures(body) {
+                    tool_name = caps.name("name").map(|m| m.as_str().to_string());
                 }
             }
 
             let mut params = Map::new();
 
-            // Extract <parameter name="...">
+            // Extract <parameter name="..."> or <parameter=...>
             for (pname, pval) in extract_xml_parameters(body) {
                 let is_code = self.config.code_param_keys.contains(&pname);
-                params.insert(pname, Value::String(clean_param_val(&pval, is_code)));
+                let cleaned = clean_param_val(&pval, is_code);
+                let val_json = if !is_code && (cleaned.starts_with('{') || cleaned.starts_with('['))
+                {
+                    if let Some(j) = safe_json_loads(&cleaned) {
+                        j
+                    } else {
+                        Value::String(cleaned)
+                    }
+                } else {
+                    Value::String(cleaned)
+                };
+                params.insert(pname, val_json);
             }
 
             // Extract <arguments>...</arguments>

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/crates/agent-tool-parser-core/src/raw.rs

@@ -132,10 +132,22 @@ impl RawToolCall {
 /// Extract raw tool calls from text without full JSON deserialization overhead.
 pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
     let clean = strip_thinking(text);
+    let lower = clean.to_lowercase();
+    let cleaned_buf;
+    let clean = if (lower.contains("<tool_call>") || lower.contains("</tool_call>"))
+        && (lower.contains("<function") || lower.contains("<invoke") || lower.contains("<action"))
+    {
+        cleaned_buf = crate::parser::TOOL_CALL_CONTAINER_RE
+            .replace_all(&clean, "")
+            .into_owned();
+        &cleaned_buf
+    } else {
+        &clean
+    };
     let mut results = Vec::new();
 
     // 1. DSML and XML invocation blocks
-    for caps in INVOKE_RE.captures_iter(&clean) {
+    for caps in INVOKE_RE.captures_iter(clean) {
         let full = caps.get(0).unwrap().as_str();
         let colon_tool = caps.name("colon_tool").map(|m| m.as_str().trim());
         let attrs = caps.name("attrs").map(|m| m.as_str()).unwrap_or("");
@@ -151,11 +163,22 @@ pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
             None
         };
 
-        let name = name_opt.or_else(|| {
-            ATTR_NAME_RE
-                .captures(attrs)
-                .map(|c| c.get(1).unwrap().as_str().trim().to_string())
-        });
+        let name = name_opt
+            .or_else(|| {
+                ATTR_NAME_RE
+                    .captures(attrs)
+                    .map(|c| c.get(1).unwrap().as_str().trim().to_string())
+            })
+            .or_else(|| {
+                crate::parser::CHILD_TAG_NAME_RE
+                    .captures(body)
+                    .map(|c| c.get(1).unwrap().as_str().trim().to_string())
+            })
+            .or_else(|| {
+                crate::parser::CHILD_TAG_FN_EQ_RE
+                    .captures(body)
+                    .map(|c| c.name("name").unwrap().as_str().trim().to_string())
+            });
 
         if let Some(tname) = name {
             if !tname.is_empty() {
@@ -169,7 +192,7 @@ pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
     }
 
     // 2. Native DeepSeek tokens
-    for caps in NATIVE_DEEPSEEK_RE.captures_iter(&clean) {
+    for caps in NATIVE_DEEPSEEK_RE.captures_iter(clean) {
         let full = caps.get(0).unwrap().as_str();
         let name = caps.name("name").unwrap().as_str().trim();
         let args = caps.name("args").unwrap().as_str().trim();
@@ -183,7 +206,7 @@ pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
     }
 
     // 3. Qwen action tokens
-    for caps in QWEN_ACTION_RE.captures_iter(&clean) {
+    for caps in QWEN_ACTION_RE.captures_iter(clean) {
         let full = caps.get(0).unwrap().as_str();
         let name = caps.name("name").unwrap().as_str().trim();
         let args = caps.name("args").unwrap().as_str().trim();
@@ -197,7 +220,7 @@ pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
     }
 
     // 4. Mistral [TOOL_CALLS]
-    if let Some(caps) = MISTRAL_RE.captures(&clean) {
+    if let Some(caps) = MISTRAL_RE.captures(clean) {
         let full = caps.get(0).unwrap().as_str();
         let arr_str = caps.get(1).unwrap().as_str();
         if let Some(Value::Array(items)) = safe_json_loads(arr_str) {
@@ -225,7 +248,7 @@ pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
     }
 
     // 5. ReAct pattern
-    if let Some(caps) = REACT_ACTION_RE.captures(&clean) {
+    if let Some(caps) = REACT_ACTION_RE.captures(clean) {
         let full = caps.get(0).unwrap().as_str();
         let name = caps.name("name").unwrap().as_str().trim();
         let args = caps.name("args").unwrap().as_str().trim();
@@ -239,7 +262,7 @@ pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
     }
 
     // 6. JSON objects in Markdown or raw text
-    let json_objs = extract_json_objects(&clean);
+    let json_objs = extract_json_objects(clean);
     for raw_json in json_objs {
         if let Some(Value::Object(map)) = safe_json_loads(&raw_json) {
             // Check standard OpenAI tool_calls structure
@@ -307,7 +330,7 @@ pub fn extract_raw_tool_calls(text: &str) -> Vec<RawToolCall> {
 
     // 7. Python function calls in Markdown or raw text
     let py_calls = crate::python_calls::extract_python_function_calls(
-        &clean,
+        clean,
         &crate::models::ToolParserConfig::default(),
     );
     for pc in py_calls {

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/crates/agent-tool-parser-core/src/streaming.rs

@@ -13,7 +13,7 @@ static ATTR_NAME_RE: Lazy<Regex> = Lazy::new(|| {
 });
 
 static TAG_CLOSE_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r#"(?is)</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*[\w-]+)?\s*>"#).unwrap()
+    Regex::new(r#"(?is)</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*[\w.:-]+)?\s*>"#).unwrap()
 });
 
 static NATIVE_TOKEN_START_RE: Lazy<Regex> = Lazy::new(|| {
@@ -146,7 +146,7 @@ impl StreamingToolParser {
 
                     // 2. Check for XML / DSML invoke tag
                     static INVOKE_OPEN_RE: Lazy<Regex> = Lazy::new(|| {
-                        Regex::new(r#"(?is)<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*(?P<colon_tool>[\w-]+))?\b(?P<attrs>[^>]*)>"#).unwrap()
+                        Regex::new(r#"(?is)<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*['"]?(?P<colon_tool>[\w.:-]+)['"]?)?\b(?P<attrs>[^>]*)>"#).unwrap()
                     });
 
                     if let Some(caps) = INVOKE_OPEN_RE.captures(&self.buffer) {
@@ -166,11 +166,28 @@ impl StreamingToolParser {
                             None
                         };
 
-                        let name_opt = raw_name.or_else(|| {
-                            ATTR_NAME_RE
-                                .captures(attrs)
-                                .map(|c| c.get(1).unwrap().as_str().trim().to_string())
-                        });
+                        let name_opt = raw_name
+                            .or_else(|| {
+                                ATTR_NAME_RE
+                                    .captures(attrs)
+                                    .map(|c| c.get(1).unwrap().as_str().trim().to_string())
+                            })
+                            .or_else(|| {
+                                let tag_lower = caps
+                                    .name("tag")
+                                    .map(|t| t.as_str().to_lowercase())
+                                    .unwrap_or_default();
+                                if tag_lower == "tool_call" || tag_lower == "tool_calls" {
+                                    let after_tag = &self.buffer[end..];
+                                    let check_len =
+                                        crate::parser::floor_char_boundary(after_tag, 300);
+                                    JSON_NAME_RE.captures(&after_tag[..check_len]).map(|c| {
+                                        c.name("name").unwrap().as_str().trim().to_string()
+                                    })
+                                } else {
+                                    None
+                                }
+                            });
 
                         if let Some(name) = name_opt {
                             let norm_name = self.parser.normalize_name(&name);
@@ -327,8 +344,9 @@ impl StreamingToolParser {
                         }
 
                         if self.buffer.len() > 500 {
-                            if let Some(nl) = self.buffer[100..].find('\n') {
-                                let cut = 100 + nl + 1;
+                            let check_start = crate::parser::floor_char_boundary(&self.buffer, 100);
+                            if let Some(nl) = self.buffer[check_start..].find('\n') {
+                                let cut = check_start + nl + 1;
                                 events.push(StreamEvent::Text(self.buffer[..cut].to_string()));
                                 self.buffer = self.buffer[cut..].to_string();
                                 continue;
@@ -421,7 +439,12 @@ impl StreamingToolParser {
                         // Construct synthetic full string for parsing if needed
                         let synthetic = match format {
                             ToolStreamFormat::XmlDsml => {
-                                format!(r#"<invoke name="{}">{}</invoke>"#, name, call_str)
+                                let trimmed = call_str.trim();
+                                if trimmed.starts_with('{') {
+                                    trimmed.to_string()
+                                } else {
+                                    format!(r#"<invoke name="{}">{}</invoke>"#, name, call_str)
+                                }
                             }
                             ToolStreamFormat::NativeToken => {
                                 format!(
@@ -512,7 +535,12 @@ impl StreamingToolParser {
                 if !self.buffer.is_empty() {
                     let synthetic = match format {
                         ToolStreamFormat::XmlDsml => {
-                            format!(r#"<invoke name="{}">{}</invoke>"#, name, self.buffer)
+                            let trimmed = self.buffer.trim();
+                            if trimmed.starts_with('{') {
+                                trimmed.to_string()
+                            } else {
+                                format!(r#"<invoke name="{}">{}</invoke>"#, name, self.buffer)
+                            }
                         }
                         ToolStreamFormat::NativeToken => {
                             format!(
@@ -658,4 +686,28 @@ mod tests {
         assert!(completed.is_some());
         assert_eq!(completed.unwrap().name, "search");
     }
+
+    #[test]
+    fn test_streaming_qwen_xml() {
+        let mut parser = StreamingToolParser::new();
+        let chunk1 = "Let me check:\n<function=calculator>\n<parameter=expression>";
+        let events1 = parser.feed(chunk1);
+        assert!(events1.iter().any(
+            |e| matches!(e, StreamEvent::ToolCallStarted { name, .. } if name == "calculator")
+        ));
+
+        let chunk2 = "2 + 2</parameter>\n</function>\nResult ready.";
+        let events2 = parser.feed(chunk2);
+        let completed = events2.iter().find_map(|e| match e {
+            StreamEvent::ToolCallCompleted(tc) => Some(tc),
+            _ => None,
+        });
+        assert!(completed.is_some());
+        let tc = completed.unwrap();
+        assert_eq!(tc.name, "calculator");
+        assert_eq!(tc.args["expression"], "2 + 2");
+        assert!(events2
+            .iter()
+            .any(|e| matches!(e, StreamEvent::Text(t) if t.contains("Result ready"))));
+    }
 }

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/crates/agent-tool-parser-core/tests/benchmark_tests.rs

@@ -280,3 +280,36 @@ fn test_large_payload_stability_and_performance() {
         elapsed_ms
     );
 }
+
+#[test]
+fn test_qwen_xml_function_parameter_format() {
+    let text = "<function=get_current_weather>\n    <parameter=location>San Francisco, CA</parameter>\n    <parameter=format>celsius</parameter>\n    </function>";
+    let call = parse_tool_call(text).unwrap();
+    assert_eq!(call.name, "get_current_weather");
+    assert_eq!(call.args["location"], "San Francisco, CA");
+    assert_eq!(call.args["format"], "celsius");
+}
+
+#[test]
+fn test_qwen_xml_wrapped_in_tool_call() {
+    let text = r#"<tool_call>
+<function=get_current_weather>
+<parameter=location>Tokyo</parameter>
+<parameter=unit>celsius</parameter>
+</function>
+</tool_call>"#;
+    let call = parse_tool_call(text).unwrap();
+    assert_eq!(call.name, "get_current_weather");
+    assert_eq!(call.args["location"], "Tokyo");
+    assert_eq!(call.args["unit"], "celsius");
+}
+
+#[test]
+fn test_tool_call_with_raw_json() {
+    let text = r#"<tool_call>
+{"name": "fetch", "arguments": {"url": "https://api.inboost.pro"}}
+</tool_call>"#;
+    let call = parse_tool_call(text).unwrap();
+    assert_eq!(call.name, "fetch");
+    assert_eq!(call.args["url"], "https://api.inboost.pro");
+}

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/crates/agent-tool-parser-core/tests/degenerate_tests.rs

@@ -442,3 +442,16 @@ fn test_degenerate_massive_string_without_catastrophic_backtracking() {
         elapsed
     );
 }
+
+#[test]
+fn test_degenerate_utf8_char_boundary_error_preview() {
+    // 98 ASCII bytes + 3-byte CJK character '钮' (bytes 98..101).
+    // Slicing at byte 100 without boundary check panics with non-char-boundary.
+    let input = format!("{}钮", "a".repeat(98));
+    let err = parse_tool_call(&input).unwrap_err();
+    assert!(err.to_string().contains("No valid tool call found"));
+
+    // Also verify non-raising try_parse variants return empty / None without panic
+    assert!(try_parse_tool_call(&input).is_none());
+    assert!(try_parse_tool_calls(&input).is_empty());
+}

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/pyproject.toml

@@ -11,7 +11,7 @@ include = ["LICENSE"]
 
 [project]
 name = "agent-tool-parser"
-version = "0.1.4"
+version = "0.1.6"
 description = "High-performance dual-engine (Rust + Python) tool call parser for DeepSeek R1/V3, Claude 3.7, Qwen 2.5, Llama 3, OpenAI & ReAct formats with auto-repair and zero dependencies."
 readme = "README.md"
 requires-python = ">=3.9"

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/src/agent_tool_parser/__init__.py

@@ -149,7 +149,7 @@ if not hasattr(ToolCall, "is_search"):
 if not hasattr(ToolCall, "is_submit"):
     ToolCall.is_submit = property(lambda self: is_submit_tool(self.name))
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"
 __all__ = [
     "ACCELERATED",
     "ARG_ALIASES",

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/src/agent_tool_parser/parser.py

@@ -55,43 +55,43 @@ _JSON_ARRAY_BLOCK_RE = re.compile(r"```(?:json)?\s*(\[.*?\])\s*```", re.DOTALL)
 
 _INVOKE_TAGS = (
     r"tool_invoke|invoke|tool_call|call|tool|invocation|"
-    r"function_call|function|action|tool_use|ant_tool_use|function_use|"
+    r"function_call|function|func|action|tool_use|ant_tool_use|function_use|"
     r"действие|вызов_функции|функция|инструмент"
 )
 
 _INVOKE_RE = re.compile(
     r"""<[｜|]*(?:dsml[｜|]*)?(?P<tag>""" + _INVOKE_TAGS + r""")"""
-    r"""(?::\s*(?P<colon_tool>[\w-]+))?\b(?P<attrs>[^>]*)>(?P<body>.*?)"""
-    r"""(?:</[｜|]*(?:dsml[｜|]*)?(?P=tag)(?::\s*[\w-]+)?\s*>|"""
+    r"""(?:(?::|=)\s*['"]?(?P<colon_tool>[\w.:-]+)['"]?)?\b(?P<attrs>[^>]*)>(?P<body>.*?)"""
+    r"""(?:</[｜|]*(?:dsml[｜|]*)?(?P=tag)(?:(?::|=)\s*[\w.:-]+)?\s*>|"""
     r"""(?=<[｜|]*(?:dsml[｜|]*)?(?:""" + _INVOKE_TAGS + r""")\b)|"""
-    r"""(?=</[｜|]*(?:dsml[｜|]*)?(?:tool_calls|function_calls|calls|tools)\s*>)|$)""",
+    r"""(?=</[｜|]*(?:dsml[｜|]*)?(?:tool_call|tool_calls|function_calls|calls|tools)\s*>)|$)""",
     re.DOTALL | re.IGNORECASE,
 )
 
 _PARAM_RE = re.compile(
-    r"""<[｜|]*(?:dsml[｜|]*)?(?P<ptag>parameter|param|arg|argument|параметр|аргумент)\b[^>]*?\bname\s*=\s*['"]?(?P<pname>[\w-]+)['"]?[^>]*>(?P<pval>.*?)"""
-    r"""(?:</[｜|]*(?:dsml[｜|]*)?(?P=ptag)\s*>|"""
+    r"""<[｜|]*(?:dsml[｜|]*)?(?P<ptag>parameter|param|arg|argument|параметр|аргумент)(?:=\s*['"]?(?P<pname_eq>[\w.:-]+)['"]?|\b[^>]*?\bname\s*=\s*['"]?(?P<pname>[\w.:-]+)['"]?)[^>]*>(?P<pval>.*?)"""
+    r"""(?:</[｜|]*(?:dsml[｜|]*)?(?P=ptag)(?:(?::|=)\s*[\w.:-]+)?\s*>|"""
     r"""(?=<[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)\b)|"""
     r"""(?=</?[｜|]*(?:dsml[｜|]*)?(?:"""
     + _INVOKE_TAGS
-    + r"""|tool_calls|function_calls|calls|tools)\b)|$)""",
+    + r"""|tool_call|tool_calls|function_calls|calls|tools)\b)|$)""",
     re.DOTALL | re.IGNORECASE,
 )
 
 _PARAM_START_RE = re.compile(
-    r"""<[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)\b[^>]*?\bname\s*=\s*['"]?(?P<pname>[\w-]+)['"]?[^>]*>""",
+    r"""<[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)(?:=\s*['"]?(?P<pname_eq>[\w.:-]+)['"]?|\b[^>]*?\bname\s*=\s*['"]?(?P<pname>[\w.:-]+)['"]?)[^>]*>""",
     re.IGNORECASE,
 )
 
 _PARAM_END_RE = re.compile(
-    r"""</[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)\s*>""",
+    r"""</[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)(?:(?::|=)\s*[\w.:-]+)?\s*>""",
     re.IGNORECASE,
 )
 
 _INVOKE_END_RE = re.compile(
     r"""</[｜|]*(?:dsml[｜|]*)?(?:"""
     + _INVOKE_TAGS
-    + r""")(?:(?::\s*[\w-]+)?\s*>)|</[｜|]*(?:dsml[｜|]*)?(?:tool_calls|function_calls|calls|tools)\s*>""",
+    + r""")(?:(?::|=)\s*[\w.:-]+)?\s*>|</[｜|]*(?:dsml[｜|]*)?(?:tool_call|tool_calls|function_calls|calls|tools)\s*>""",
     re.IGNORECASE,
 )
 
@@ -132,7 +132,10 @@ def _extract_xml_parameters(body: str) -> list[tuple[str, str]]:
         s = m.start()
         if any(cs <= s < ce for cs, ce in cdata_spans):
             continue
-        starts.append((s, m.end(), m.group("pname").strip().lower()))
+        pname = (m.group("pname") or m.group("pname_eq") or "").strip().lower()
+        if not pname:
+            continue
+        starts.append((s, m.end(), pname))
 
     results: list[tuple[str, str]] = []
     for i in range(len(starts)):
@@ -203,6 +206,10 @@ _CHILD_TOOL_NAME_RE = re.compile(
     r"<(?:name|tool_name|function_name|tool|function)>\s*([\w-]+)(?:</(?:name|tool_name|function_name|tool|function)>|\s|$)",
     re.IGNORECASE,
 )
+_CHILD_TOOL_FN_EQ_RE = re.compile(
+    r"""<[｜|]*(?:dsml[｜|]*)?(?:function|tool|invoke|action|func)\s*=\s*['"]?([\w.:-]+)""",
+    re.IGNORECASE,
+)
 _ARGUMENTS_BLOCK_RE = re.compile(
     r"<(?:arguments|parameters)>(.*?)(?:</(?:arguments|parameters)>|$)",
     re.DOTALL | re.IGNORECASE,
@@ -540,6 +547,12 @@ class ToolParser:
         if "<" not in text:
             return []
 
+        lower = text.lower()
+        if ("<tool_call>" in lower or "</tool_call>" in lower) and any(
+            t in lower for t in ("<function", "<invoke", "<action")
+        ):
+            text = re.sub(r"</?[｜|]*(?:dsml[｜|]*)?tool_call\s*>", "", text)
+
         calls: list[ToolCall] = []
 
         # 1. Hermes / Kimi direct tags format: <tool_name>search</tool_name><pattern>...</pattern>
@@ -584,18 +597,27 @@ class ToolParser:
                 if m_fn:
                     tool_name = m_fn.group(1)
 
-            # Check child tags for tool name (Anthropic format: <name>read_file</name>)
+            # Check child tags for tool name (Anthropic format: <name>read_file</name> or <function=search>)
             if not tool_name:
                 m_child = _CHILD_TOOL_NAME_RE.search(body)
                 if m_child:
                     tool_name = m_child.group(1)
+                else:
+                    m_child_eq = _CHILD_TOOL_FN_EQ_RE.search(body)
+                    if m_child_eq:
+                        tool_name = m_child_eq.group(1)
 
             params = {}
 
-            # Check DSML / standard parameter tags: <parameter name="...">
+            # Check DSML / standard parameter tags: <parameter name="..."> or <parameter=...>
             for pname, pval in _extract_xml_parameters(body):
                 is_code = pname in self.code_param_keys
-                params[pname] = clean_param_val(pval, is_code_param=is_code)
+                cleaned = clean_param_val(pval, is_code_param=is_code)
+                if not is_code and (cleaned.startswith("{") or cleaned.startswith("[")):
+                    parsed_val = safe_json_loads(cleaned, default=None)
+                    params[pname] = parsed_val if parsed_val is not None else cleaned
+                else:
+                    params[pname] = cleaned
 
             # Check for <arguments>...</arguments> or <parameters>...</parameters> block (Anthropic)
             m_wrap = _ARGUMENTS_BLOCK_RE.search(body)

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/src/agent_tool_parser/raw.py

@@ -20,8 +20,18 @@ _ATTR_NAME_RE = re.compile(
     re.IGNORECASE,
 )
 
+_CHILD_TOOL_NAME_RE = re.compile(
+    r"<(?:name|tool_name|function_name|tool|function)>\s*([\w-]+)(?:</(?:name|tool_name|function_name|tool|function)>|\s|$)",
+    re.IGNORECASE,
+)
+
+_CHILD_TOOL_FN_EQ_RE = re.compile(
+    r"""<[｜|]*(?:dsml[｜|]*)?(?:function|tool|invoke|action|func)\s*=\s*['"]?([\w.:-]+)""",
+    re.IGNORECASE,
+)
+
 _INVOKE_RE = re.compile(
-    r"<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*(?P<colon_tool>[\w-]+))?\b(?P<attrs>[^>]*)>(?P<body>.*?)(?:</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*[\w-]+)?\s*>|<[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)\b|</[｜|]*(?:dsml[｜|]*)?(?:tool_calls|function_calls|calls|tools)\s*>|$)",
+    r"<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*['\"]?(?P<colon_tool>[\w.:-]+)['\"]?)?\b(?P<attrs>[^>]*)>(?P<body>.*?)(?:</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*[\w.:-]+)?\s*>|<[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)\b|</[｜|]*(?:dsml[｜|]*)?(?:tool_call|tool_calls|function_calls|calls|tools)\s*>|$)",
     re.IGNORECASE | re.DOTALL,
 )
 
@@ -43,12 +53,12 @@ _REACT_ACTION_RE = re.compile(
 _MISTRAL_RE = re.compile(r"\[TOOL_CALLS\]\s*(\[\s*\{.*?\}\s*\])", re.IGNORECASE | re.DOTALL)
 
 _PARAM_START_RE = re.compile(
-    r"<[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)\b[^>]*?\bname\s*=\s*['\"]?(?P<pname>[\w-]+)['\"]?[^>]*>",
+    r"<[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)(?:=\s*['\"]?(?P<pname_eq>[\w.:-]+)['\"]?|\b[^>]*?\bname\s*=\s*['\"]?(?P<pname>[\w.:-]+)['\"]?)[^>]*>",
     re.IGNORECASE | re.DOTALL,
 )
 
 _PARAM_END_RE = re.compile(
-    r"</[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)\s*>",
+    r"</[｜|]*(?:dsml[｜|]*)?(?:parameter|param|arg|argument|параметр|аргумент)(?:(?::|=)\s*[\w.:-]+)?\s*>",
     re.IGNORECASE | re.DOTALL,
 )
 
@@ -98,7 +108,9 @@ class RawToolCall:
                 start = m.start()
                 if any(cs <= start < ce for cs, ce in cdata_spans):
                     continue
-                pname = m.group("pname").strip().lower()
+                pname = (m.group("pname") or m.group("pname_eq") or "").strip().lower()
+                if not pname:
+                    continue
                 valid_starts.append((start, m.end(), pname))
 
             for i, (_, val_start, pname) in enumerate(valid_starts):
@@ -163,6 +175,11 @@ class RawToolCall:
 def extract_raw_tool_calls(text: str) -> list[RawToolCall]:
     """Extract raw tool calls from text without full JSON parsing overhead."""
     clean = strip_thinking(text)
+    lower = clean.lower()
+    if ("<tool_call>" in lower or "</tool_call>" in lower) and any(
+        t in lower for t in ("<function", "<invoke", "<action")
+    ):
+        clean = re.sub(r"</?[｜|]*(?:dsml[｜|]*)?tool_call\s*>", "", clean)
     results: list[RawToolCall] = []
 
     # 1. DSML and XML invocation blocks
@@ -179,6 +196,14 @@ def extract_raw_tool_calls(text: str) -> list[RawToolCall]:
             attr_m = _ATTR_NAME_RE.search(attrs)
             if attr_m:
                 name = attr_m.group(1).strip()
+            else:
+                m_child = _CHILD_TOOL_NAME_RE.search(body)
+                if m_child:
+                    name = m_child.group(1).strip()
+                else:
+                    m_child_eq = _CHILD_TOOL_FN_EQ_RE.search(body)
+                    if m_child_eq:
+                        name = m_child_eq.group(1).strip()
 
         if name:
             results.append(RawToolCall(name=name, raw_args=body.strip(), raw_source=full))

{agent_tool_parser-0.1.4 → agent_tool_parser-0.1.6}/src/agent_tool_parser/streaming.py

@@ -15,12 +15,12 @@ _ATTR_NAME_RE = re.compile(
 )
 
 _INVOKE_OPEN_RE = re.compile(
-    r"<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*(?P<colon_tool>[\w-]+))?\b(?P<attrs>[^>]*)>",
+    r"<[｜|]*(?:dsml[｜|]*)?(?P<tag>tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*['\"]?(?P<colon_tool>[\w.:-]+)['\"]?)?\b(?P<attrs>[^>]*)>",
     re.IGNORECASE,
 )
 
 _TAG_CLOSE_RE = re.compile(
-    r"</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?::\s*[\w-]+)?\s*>",
+    r"</[｜|]*(?:dsml[｜|]*)?(?:tool_invoke|invoke|tool_call|call|tool|invocation|function_call|function|func|action|tool_use|ant_tool_use|function_use|действие|вызов_функции|функция|инструмент)(?:(?::|=)\s*[\w.:-]+)?\s*>",
     re.IGNORECASE,
 )
 
@@ -198,6 +198,11 @@ class StreamingToolParser:
                         attr_m = _ATTR_NAME_RE.search(attrs)
                         if attr_m:
                             raw_name = attr_m.group(1).strip()
+                        elif m.group("tag").lower() in ("tool_call", "tool_calls"):
+                            after_tag = self.buffer[end:]
+                            json_m = _JSON_NAME_RE.search(after_tag[:300])
+                            if json_m:
+                                raw_name = json_m.group("name").strip()
 
                     if raw_name:
                         norm_name = self.parser.normalize_name(raw_name)
@@ -433,7 +438,10 @@ class StreamingToolParser:
                     call_str = self.buffer[:body_end]
                     name = self._current_name or "unknown"
                     if self._current_format == "xml_dsml":
-                        synthetic = f'<invoke name="{name}">{call_str}</invoke>'
+                        if call_str.strip().startswith("{"):
+                            synthetic = call_str.strip()
+                        else:
+                            synthetic = f'<invoke name="{name}">{call_str}</invoke>'
                     elif self._current_format == "native_token":
                         synthetic = f"<｜tool call begin｜>function={name}<｜tool sep｜>{call_str}<｜tool call end｜>"
                     elif self._current_format == "qwen":
@@ -495,7 +503,10 @@ class StreamingToolParser:
             if self.buffer:
                 name = self._current_name or "unknown"
                 if self._current_format == "xml_dsml":
-                    synthetic = f'<invoke name="{name}">{self.buffer}</invoke>'
+                    if self.buffer.strip().startswith("{"):
+                        synthetic = self.buffer.strip()
+                    else:
+                        synthetic = f'<invoke name="{name}">{self.buffer}</invoke>'
                 elif self._current_format == "native_token":
                     synthetic = f"<｜tool call begin｜>function={name}<｜tool sep｜>{self.buffer}<｜tool call end｜>"
                 elif self._current_format == "qwen":