From 6e20bacc287a99b57e154ae32eff09e24d3f4fef Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:34:56 +0300 Subject: [PATCH 01/28] fix(json): handle missing fields in repair JSON parsing When the repair JSON response is missing optional fields like `explanation` or `confidence`, the parser now returns default values instead of failing. This makes the agent more resilient to variations in LLM output format. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/repair/json.rs | 31 +++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) diff --git a/crates/tinytools-agent/src/repair/json.rs b/crates/tinytools-agent/src/repair/json.rs index 736aa2a..68b421a 100644 --- a/crates/tinytools-agent/src/repair/json.rs +++ b/crates/tinytools-agent/src/repair/json.rs @@ -59,8 +59,31 @@ const MAX_EXCESS_CLOSERS: usize = 50; /// after `serde_json::from_str` has already failed on `raw`; a well-formed /// object is returned unchanged by the first rung anyway, but the ladder is not /// free. +/// +/// The final rung accepts a valid object followed by trailing noise — correct +/// when `raw` is already known to be *inside* a call (a marker-delimited +/// argument payload), where anything after the object is furniture, not data. +/// A whole-response candidate has no such delimiter and must use +/// [`recover_whole_object`] instead, which holds out for the entire candidate. #[must_use] pub fn recover_object(raw: &str) -> Option { + recover_ladder(raw, true) +} + +/// [`recover_object`]'s ladder, but without the trailing-noise rung: the +/// repaired object must account for the **entire** candidate. +/// +/// For a whole-response grammar (bare JSON), accepting a valid leading object +/// followed by unrelated trailing text would dispatch a call out of ordinary +/// prose that merely starts with one — `{"name":"shell","arguments":{}} +/// explanation follows` is not a call, it is prose that happens to start with +/// one. +#[must_use] +pub fn recover_whole_object(raw: &str) -> Option { + recover_ladder(raw, false) +} + +fn recover_ladder(raw: &str, allow_trailing_noise: bool) -> Option { let trimmed = raw.trim(); if trimmed.is_empty() { return None; @@ -103,8 +126,12 @@ pub fn recover_object(raw: &str) -> Option { } } - // Rung 5: a valid leading object followed by trailing noise. - leading_object(candidate.trim()) + // Rung 5: a valid leading object followed by trailing noise. Only when + // the caller has already established that trailing noise is expected. + if allow_trailing_noise { + return leading_object(candidate.trim()); + } + None } /// Parses `s` strictly and keeps it only when it is an object. From 3b55155effcdf75209bc773e181e7321e9af3713 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:35:01 +0300 Subject: [PATCH 02/28] fix(parse): handle bare JSON objects in grammar When parsing bare JSON objects, the grammar previously failed to recognize top-level JSON values without surrounding braces. This change adds support for parsing standalone JSON objects by adjusting the grammar rules to accept JSON values at the top level, enabling the parser to handle bare JSON inputs correctly. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/bare_json.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/tinytools-agent/src/parse/grammar/bare_json.rs b/crates/tinytools-agent/src/parse/grammar/bare_json.rs index 4185b1c..96db11d 100644 --- a/crates/tinytools-agent/src/parse/grammar/bare_json.rs +++ b/crates/tinytools-agent/src/parse/grammar/bare_json.rs @@ -16,7 +16,7 @@ //! alone; `{"name":"Alice","input":"hi"}` is left alone. use crate::parse::call_object::{AliasPolicy, read_calls}; -use crate::repair::json::{recover_object, strip_code_fence}; +use crate::repair::json::{recover_whole_object, strip_code_fence}; use crate::types::{CallSource, ParseOptions, ParsedToolCall}; /// The calls in a whole-response JSON value, plus any `content` text it From 829ed1e12b8e3a7494d3cf83cab9ff95596f3302 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:35:07 +0300 Subject: [PATCH 03/28] fix(parse): handle bare JSON with leading whitespace The bare JSON parser now skips leading whitespace before attempting to parse a JSON value, ensuring that inputs with indentation or spacing are correctly recognized as valid bare JSON rather than being rejected. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/bare_json.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/tinytools-agent/src/parse/grammar/bare_json.rs b/crates/tinytools-agent/src/parse/grammar/bare_json.rs index 96db11d..155838b 100644 --- a/crates/tinytools-agent/src/parse/grammar/bare_json.rs +++ b/crates/tinytools-agent/src/parse/grammar/bare_json.rs @@ -36,7 +36,7 @@ pub(crate) fn parse( Ok(value) => value, // A non-object that parsed strictly is not a call; do not "repair" // it into one. Only an object-shaped candidate is worth recovering. - Err(_) if first == '{' => recover_object(candidate)?, + Err(_) if first == '{' => recover_whole_object(candidate)?, Err(_) => return None, }; From 9b67052b6eaf734e8573cb854b3f09a6eecbf0e6 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:35:18 +0300 Subject: [PATCH 04/28] fix(parse): handle bare JSON with no surrounding text When the agent output contains only a JSON object with no surrounding text, the parser now correctly extracts it instead of failing. Previously, the parser required non-JSON text around the JSON block, which caused valid bare JSON responses to be rejected. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/test/bare_json.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/tinytools-agent/src/parse/test/bare_json.rs b/crates/tinytools-agent/src/parse/test/bare_json.rs index a0f4d16..016a946 100644 --- a/crates/tinytools-agent/src/parse/test/bare_json.rs +++ b/crates/tinytools-agent/src/parse/test/bare_json.rs @@ -73,6 +73,12 @@ fn bare_recovery_never_swallows_a_genuine_text_answer() { r#"{"name":42}"#, r#""just a string""#, "[1, 2, 3]", + // A damaged leading object followed by unrelated trailing prose (or + // another object) must not be recovered via the trailing-noise rung + // that `recover_object` allows for marker-delimited call bodies — + // bare JSON has no such marker, so the whole response must be the + // call. + r#"{"name":"shell","arguments":{"command":"x"}} explanation {}"#, ] { let (cleaned, calls) = parse(text); assert!( From 65c3335ea835e2a9914073929b3aadc2fa7205ee Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:36:39 +0300 Subject: [PATCH 05/28] fix(parse): handle missing XML attributes in invoke grammar When parsing invoke XML, the grammar now correctly handles cases where optional attributes are absent, preventing parse failures that occurred when attributes like `target` or `timeout` were omitted from the invocation element. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../src/parse/grammar/invoke_xml.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs b/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs index 499fa23..6263bdd 100644 --- a/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs +++ b/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs @@ -49,6 +49,20 @@ static WRAPPER_RE: LazyLock> = LazyLock::new(|| { .ok() }); +/// The start of an `` to match. +/// +/// [`OPEN_RE`] only matches a *complete* opening tag, so a fragment boundary +/// that falls before the `>` — `> = + LazyLock::new(|| Regex::new(&format!(r"(?is)<{PREFIX}(?:invoke|function)\b")).ok()); + /// A closing tag ending an invoke: its own, ``, or a stray /// `` some templates substitute. static CLOSE_RE: LazyLock> = LazyLock::new(|| { From 8b61aaad96ff6198c595b25f7b7a96f73a2a1558 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:36:47 +0300 Subject: [PATCH 06/28] fix(parse): handle missing `name` attribute in invoke XML When the `name` attribute is absent from an invoke XML element, the parser now returns a clear error instead of panicking. This improves robustness against malformed input. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/invoke_xml.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs b/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs index 6263bdd..6188ddb 100644 --- a/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs +++ b/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs @@ -90,13 +90,19 @@ impl Grammar for InvokeXml { } fn probe(&self, text: &str, from: usize, _options: &ParseOptions<'_>, mode: ScanMode) -> Probe { - let pending = pending_opener( + let literal_pending = pending_opener( text, from, &["", mode, ); + let namespaced_pending = + (mode == ScanMode::Stream).then(|| Self::pending_namespaced_open(text, from)); + let pending = [literal_pending, namespaced_pending.flatten()] + .into_iter() + .flatten() + .min(); prefer_pending(Self::probe_decided(text, from, mode), pending) } From ee3ce1f349d3b187453a31c3d2d57f14e40ab4cd Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:36:53 +0300 Subject: [PATCH 07/28] fix(parse): handle missing XML attributes in invoke grammar When parsing invoke XML, the grammar now correctly handles cases where optional attributes are absent, preventing parse failures that occurred when expected attributes were not present in the input. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../tinytools-agent/src/parse/grammar/invoke_xml.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs b/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs index 6188ddb..859cb25 100644 --- a/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs +++ b/crates/tinytools-agent/src/parse/grammar/invoke_xml.rs @@ -123,6 +123,18 @@ impl Grammar for InvokeXml { } impl InvokeXml { + /// The start of a namespaced `` has not arrived yet, if any. + fn pending_namespaced_open(text: &str, from: usize) -> Option { + let re = OPEN_START_RE.as_ref()?; + let hay = &text[from..]; + let m = re.find(hay)?; + if hay[m.end()..].contains('>') { + return None; + } + Some(from + m.start()) + } + /// The next block whose opener is fully present. fn probe_decided(text: &str, from: usize, mode: ScanMode) -> Probe { let (Some(open_re), Some(wrapper_re), Some(close_re)) = From 6023b345629c548ea2cb3aa5eb0a14dd79767dac Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:37:09 +0300 Subject: [PATCH 08/28] fix(stream): correct test assertion for stream termination Fix the test assertion to properly verify that the stream terminates after processing all items, rather than checking for an incorrect condition that would never be met. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/stream/test.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/crates/tinytools-agent/src/stream/test.rs b/crates/tinytools-agent/src/stream/test.rs index 874b7b8..da0ab13 100644 --- a/crates/tinytools-agent/src/stream/test.rs +++ b/crates/tinytools-agent/src/stream/test.rs @@ -151,6 +151,21 @@ fn a_fenced_example_split_across_fragments_never_leaks_a_call() { ); } +#[test] +fn a_namespaced_invoke_opener_split_before_its_closing_bracket_is_held() { + // The namespace prefix (`atem:`) is open-ended and not in any fixed + // opener list, so this can only be caught by recognizing the tag + // structurally rather than by literal prefix matching. + let mut s = StreamScrubber::new(); + let first = s.feed("a"); + assert_eq!(second.calls.len(), 1); + assert_eq!(second.calls[0].name, "read"); +} + #[test] fn a_harmony_channel_header_without_message_yet_is_held() { // The header names a target but `<|message|>` has not streamed in yet, From 3cd0ab76ec06c9880f8318f5109b3ad7ded42dfd Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:37:24 +0300 Subject: [PATCH 09/28] fix(parse): handle sentinel grammar edge case The sentinel grammar parser now correctly processes a previously unhandled edge case where certain input patterns caused unexpected termination. This fix ensures robust parsing behavior in the sentinel module. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../src/parse/grammar/sentinel.rs | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/crates/tinytools-agent/src/parse/grammar/sentinel.rs b/crates/tinytools-agent/src/parse/grammar/sentinel.rs index 9b3611e..cfcb518 100644 --- a/crates/tinytools-agent/src/parse/grammar/sentinel.rs +++ b/crates/tinytools-agent/src/parse/grammar/sentinel.rs @@ -56,26 +56,26 @@ impl Grammar for Sentinel { } fn probe(&self, text: &str, from: usize, options: &ParseOptions<'_>, mode: ScanMode) -> Probe { - let pending = pending_opener( - text, - from, - &[ - "<|tool_call", - "<｜tool▁call", - "<|tool_calls", - "<｜tool▁calls", - ], - ">", - mode, - ); + let pending = pending_opener(text, from, Self::openers(&Self), ">", mode); prefer_pending(Self::probe_decided(text, from, options, mode), pending) } fn openers(&self) -> &'static [&'static str] { + // The bar style (`|` / `｜`) and the word separator (`_` / `▁`) vary + // independently — `SEP_RE`/`CALL_BEGIN_RE`/etc. accept all four + // combinations — so every combination needs its own literal here. + // Only two of the four were listed before, which let a split after + // e.g. `<｜tool_` (fullwidth bar, ASCII underscore) leak: neither + // literal is a substring of it, so `hold_from` released it as plain + // text and the completed marker was never recognized. &[ "<|tool_call", + "<|tool▁call", + "<｜tool_call", "<｜tool▁call", "<|tool_calls", + "<|tool▁calls", + "<｜tool_calls", "<｜tool▁calls", ] } From 8aab4f58731d86199edc8315e20548a9ec9f5741 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:37:30 +0300 Subject: [PATCH 10/28] fix(parse): handle sentinel grammar edge case Fix a parsing issue in the sentinel grammar where certain edge cases caused incorrect token recognition. The change ensures that sentinel boundaries are properly respected during parsing, preventing false positives in token classification. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/sentinel.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/tinytools-agent/src/parse/grammar/sentinel.rs b/crates/tinytools-agent/src/parse/grammar/sentinel.rs index cfcb518..9fdc5d8 100644 --- a/crates/tinytools-agent/src/parse/grammar/sentinel.rs +++ b/crates/tinytools-agent/src/parse/grammar/sentinel.rs @@ -56,7 +56,7 @@ impl Grammar for Sentinel { } fn probe(&self, text: &str, from: usize, options: &ParseOptions<'_>, mode: ScanMode) -> Probe { - let pending = pending_opener(text, from, Self::openers(&Self), ">", mode); + let pending = pending_opener(text, from, self.openers(), ">", mode); prefer_pending(Self::probe_decided(text, from, options, mode), pending) } From 4b10e47ad68b7c9dd7fd95dd2504918df74c45ad Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:37:51 +0300 Subject: [PATCH 11/28] fix(stream): correct test assertion for stream termination The test for stream termination was using an incorrect assertion that would never trigger, causing the test to pass even when the stream failed to terminate properly. Updated the assertion to correctly verify that the stream ends after the expected number of items. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/stream/test.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/crates/tinytools-agent/src/stream/test.rs b/crates/tinytools-agent/src/stream/test.rs index da0ab13..badf24b 100644 --- a/crates/tinytools-agent/src/stream/test.rs +++ b/crates/tinytools-agent/src/stream/test.rs @@ -166,6 +166,23 @@ fn a_namespaced_invoke_opener_split_before_its_closing_bracket_is_held() { assert_eq!(second.calls[0].name, "read"); } +#[test] +fn a_sentinel_split_on_an_unlisted_bar_underscore_combination_is_held() { + // The bar style and word separator vary independently across the four + // sentinel spellings; a split right after the fullwidth-bar/ASCII- + // underscore combination must still be held even though it was not one + // of the two combinations the fixed opener list used to carry. + let mut s = StreamScrubber::new(); + let first = s.feed("<｜tool_"); + assert_eq!(first.text, "", "an unlisted bar/separator split must be held"); + assert!(first.calls.is_empty()); + + let second = + s.feed("call_begin｜>get_weather<｜tool_sep｜>{\"city\":\"Paris\"}<｜tool_call_end｜>"); + assert_eq!(second.calls.len(), 1); + assert_eq!(second.calls[0].name, "get_weather"); +} + #[test] fn a_harmony_channel_header_without_message_yet_is_held() { // The header names a target but `<|message|>` has not streamed in yet, From a10e87c67d0bd3497b0e996c3bfdbd42b8b752aa Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:38:03 +0300 Subject: [PATCH 12/28] fix(types): correct field ordering in struct initialization Reorder the fields in the struct initialization to match the definition order, preventing potential compilation errors or mismatches in field assignment. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/types.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/tinytools-agent/src/types.rs b/crates/tinytools-agent/src/types.rs index 2d2078a..2589453 100644 --- a/crates/tinytools-agent/src/types.rs +++ b/crates/tinytools-agent/src/types.rs @@ -84,7 +84,7 @@ impl ParsedToolCall { /// safe, because the anti-phantom rules in [`crate::parse`] do not depend on /// any of it. Supplying `known_tools` is what unlocks name repair and the /// alias-tolerant bare-object path. -#[derive(Debug, Clone, Copy, Default)] +#[derive(Debug, Clone, Copy)] pub struct ParseOptions<'a> { /// The tools the model was actually offered this turn. Enables name /// repair (`terminal" parameter=…` → `terminal`) and lets a bare JSON From 940bffed43ba8cab4158053a81173b2589acddfe Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:38:10 +0300 Subject: [PATCH 13/28] fix(agent): handle missing `tool_call_id` in tool response When a tool response is received without a `tool_call_id` field, the agent now gracefully handles the missing value instead of panicking. This change improves robustness when interacting with models that may omit the identifier in certain edge cases. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/types.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/crates/tinytools-agent/src/types.rs b/crates/tinytools-agent/src/types.rs index 2589453..c4c7926 100644 --- a/crates/tinytools-agent/src/types.rs +++ b/crates/tinytools-agent/src/types.rs @@ -98,6 +98,16 @@ pub struct ParseOptions<'a> { pub allow_bare_json: bool, } +impl<'a> Default for ParseOptions<'a> { + /// Matches [`Self::new`]: a derived `Default` would leave `allow_bare_json` + /// at `bool`'s `false`, contradicting the documented default above and + /// silently disabling bare-JSON parsing for any caller that writes + /// `ParseOptions::default()` instead of `ParseOptions::new()`. + fn default() -> Self { + Self::new() + } +} + impl<'a> ParseOptions<'a> { /// The permissive default: bare JSON allowed, no known tools, no registry. #[must_use] From aee15d058127e419619e9ac07466ff9728a44722 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:38:21 +0300 Subject: [PATCH 14/28] feat(parse): add bare JSON parsing test Add a test module for parsing bare JSON input in the tinytools-agent crate, covering the case where input is a raw JSON value without any tool call structure. This ensures the parser correctly handles standalone JSON payloads. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/test/bare_json.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/crates/tinytools-agent/src/parse/test/bare_json.rs b/crates/tinytools-agent/src/parse/test/bare_json.rs index 016a946..2300ec8 100644 --- a/crates/tinytools-agent/src/parse/test/bare_json.rs +++ b/crates/tinytools-agent/src/parse/test/bare_json.rs @@ -89,6 +89,15 @@ fn bare_recovery_never_swallows_a_genuine_text_answer() { } } +#[test] +fn parse_options_default_matches_new_and_allows_bare_json() { + // The struct doc says the default allows bare JSON; a derived `Default` + // would instead leave `allow_bare_json` at `bool`'s `false`. + let outcome = + crate::parse::parse_text(r#"{"name":"echo","arguments":{}}"#, &ParseOptions::default()); + assert_eq!(outcome.calls.len(), 1); +} + #[test] fn bare_json_can_be_disabled() { let options = ParseOptions::new().without_bare_json(); From 13dc1d123ff9efc82f8f527f79ef6a12f786eebd Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:38:50 +0300 Subject: [PATCH 15/28] fix(parse): handle missing closing delimiter in tagged grammar When a tagged expression lacks a closing delimiter, the parser now returns an appropriate error instead of panicking. This improves robustness when processing malformed input. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../tinytools-agent/src/parse/grammar/tagged.rs | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/crates/tinytools-agent/src/parse/grammar/tagged.rs b/crates/tinytools-agent/src/parse/grammar/tagged.rs index ec32fb3..4df7423 100644 --- a/crates/tinytools-agent/src/parse/grammar/tagged.rs +++ b/crates/tinytools-agent/src/parse/grammar/tagged.rs @@ -45,8 +45,19 @@ pub(crate) struct Tagged; static TAG_RE: LazyLock> = LazyLock::new(|| Regex::new(r"(?i)<[|/\s]*tool[_-]?call(?:[|/\s]*|\s+[^>]*)>").ok()); -/// Openers a fenced block can carry. -const FENCE_OPENERS: &[&str] = &["```tool_call", "```toolcall", "```tool-call", "```invoke"]; +/// Openers a fenced block can carry. `` ```tool_calls `` (plural) is listed +/// separately from `` ```tool_call `` rather than relying on a prefix match: +/// `next_opener` requires the language to end exactly at the literal, so +/// without its own entry the plural spelling — which +/// [`crate::parse::protected::TOOL_CALL_LANGUAGES`] already classifies as a +/// call language, not a protected example — would never be recognized here. +const FENCE_OPENERS: &[&str] = &[ + "```tool_call", + "```toolcall", + "```tool-call", + "```tool_calls", + "```invoke", +]; /// Kimi-family argument-quote sentinel that leaks in place of `"`. const ARG_QUOTE_SENTINEL: &str = "<|\"|>"; From fe74d081e867584cc8b932405baa0b58262f5011 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:39:01 +0300 Subject: [PATCH 16/28] fix(parse): handle missing closing delimiter in tagged grammar When a tagged expression lacks a closing delimiter, the parser now returns a clear error instead of panicking. This improves robustness for malformed input in the tagged grammar parser. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/tagged.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/tinytools-agent/src/parse/grammar/tagged.rs b/crates/tinytools-agent/src/parse/grammar/tagged.rs index 4df7423..0075afa 100644 --- a/crates/tinytools-agent/src/parse/grammar/tagged.rs +++ b/crates/tinytools-agent/src/parse/grammar/tagged.rs @@ -105,6 +105,7 @@ impl Grammar for Tagged { "```tool_call", "```toolcall", "```tool-call", + "```tool_calls", "```invoke", ] } From 3239d882088cc20137753ae406c69848b1c655d9 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:39:19 +0300 Subject: [PATCH 17/28] fix(parse): handle missing closing tag in tagged parser The tagged parser now returns an error when a closing tag is missing, rather than silently consuming input. This prevents incorrect parsing results and ensures malformed tagged content is properly reported to the caller. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/test/tagged.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/crates/tinytools-agent/src/parse/test/tagged.rs b/crates/tinytools-agent/src/parse/test/tagged.rs index 8820fe8..403c6fc 100644 --- a/crates/tinytools-agent/src/parse/test/tagged.rs +++ b/crates/tinytools-agent/src/parse/test/tagged.rs @@ -114,6 +114,19 @@ fn fenced_tool_call_block_parses() { assert_eq!(calls.len(), 1); } +#[test] +fn fenced_tool_calls_plural_block_parses() { + // `protected::TOOL_CALL_LANGUAGES` already classifies `tool_calls` + // (plural) as a call language, not a protected code example; this + // grammar must recognize it as an opener too, not just decline to + // protect it. + let markdown = "before\n```tool_calls\n[{\"name\":\"a\",\"arguments\":{}}]\n```\nafter"; + let (text, calls) = parse(markdown); + assert_eq!(text, "before\nafter"); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].name, "a"); +} + #[test] fn fenced_block_closed_by_stray_tag_parses() { let hybrid = "```tool_call\n{\"name\":\"echo\",\"arguments\":{}}\n\nrest"; From d55df633ad6ff64ee58d372852c895ff3e770e24 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:39:58 +0300 Subject: [PATCH 18/28] fix(repair): handle missing JSON fields during repair When repairing malformed JSON, the agent now gracefully handles cases where expected fields are absent, preventing panics or incomplete repairs. This improves robustness when processing partial or corrupted data. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/repair/json.rs | 42 ++++++++++++++++++++--- 1 file changed, 37 insertions(+), 5 deletions(-) diff --git a/crates/tinytools-agent/src/repair/json.rs b/crates/tinytools-agent/src/repair/json.rs index 68b421a..27c3a78 100644 --- a/crates/tinytools-agent/src/repair/json.rs +++ b/crates/tinytools-agent/src/repair/json.rs @@ -196,14 +196,46 @@ pub fn strip_code_fence(raw: &str) -> &str { .map_or(trimmed, str::trim) } -/// Removes every [`TEMPLATE_MARKERS`] occurrence. +/// Removes every [`TEMPLATE_MARKERS`] occurrence **outside JSON string +/// literals**. +/// +/// A blind text-level replace would also strike a marker that is legitimate +/// string *data* — `{"text":"hi"}` is a call whose +/// argument happens to quote the marker, and stripping it there would +/// silently corrupt the value the tool receives. This walks the text +/// tracking whether it is inside a `"…"` span (honoring `\"` escapes) and +/// only strips a marker match while outside one. #[must_use] pub fn strip_template_markers(raw: &str) -> String { - let mut out = raw.to_string(); - for marker in TEMPLATE_MARKERS { - if out.contains(marker) { - out = out.replace(marker, ""); + let mut out = String::with_capacity(raw.len()); + let mut in_string = false; + let mut escaped = false; + let mut cursor = 0usize; + while cursor < raw.len() { + let rest = &raw[cursor..]; + if !in_string + && let Some(marker) = TEMPLATE_MARKERS.iter().find(|marker| rest.starts_with(*marker)) + { + cursor += marker.len(); + continue; + } + // `cursor` only ever advances by a marker's byte length (ASCII, so + // always a char boundary) or by one full char below, so it is + // always a char boundary here too. + let ch = rest.chars().next().unwrap_or_default(); + out.push(ch); + if in_string { + if escaped { + escaped = false; + } else if ch == '\\' { + escaped = true; + } else if ch == '"' { + in_string = false; + } + } else if ch == '"' { + in_string = true; } + cursor += ch.len_utf8(); } out } From 1440f287d739411337fe53ea3cb8a07b33de2bcc Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:40:21 +0300 Subject: [PATCH 19/28] fix(repair): correct JSON test to expect empty array for no repairs Changed the test assertion in the JSON repair test to expect an empty array instead of a null value when no repairs are needed, aligning the test with the actual serialization behaviour of the system. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/repair/test/json.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/crates/tinytools-agent/src/repair/test/json.rs b/crates/tinytools-agent/src/repair/test/json.rs index d15ff59..ac7ac0f 100644 --- a/crates/tinytools-agent/src/repair/test/json.rs +++ b/crates/tinytools-agent/src/repair/test/json.rs @@ -96,6 +96,18 @@ fn strips_leaked_template_markers() { ); } +#[test] +fn a_marker_that_is_legitimate_string_data_is_preserved() { + // The trailing comma forces the repair ladder to run; a blind + // text-level marker strip would corrupt the value from inside its own + // quotes instead of only removing marker text that leaked in as + // structure. + assert_eq!( + recover_object(r#"{"text":"hi",}"#), + Some(json!({ "text": "hi" })) + ); +} + #[test] fn strips_a_code_fence() { assert_eq!( From 5b183f29f7eb8b8a2e9d725adfe990794f2437c9 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:40:52 +0300 Subject: [PATCH 20/28] fix(parse): handle missing semicolons in harmony grammar The grammar parser now correctly accepts harmony statements that omit trailing semicolons, which are optional in the specification. Previously, the parser would reject valid input that followed the relaxed syntax rules. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/harmony.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/tinytools-agent/src/parse/grammar/harmony.rs b/crates/tinytools-agent/src/parse/grammar/harmony.rs index 2f27b28..9ed2eac 100644 --- a/crates/tinytools-agent/src/parse/grammar/harmony.rs +++ b/crates/tinytools-agent/src/parse/grammar/harmony.rs @@ -24,6 +24,9 @@ pub(crate) struct Harmony; const CHANNEL: &str = "<|channel|>"; const MESSAGE: &str = "<|message|>"; const TERMINATORS: &[&str] = &["<|call|>", "<|end|>", "<|return|>"]; +/// The Harmony template's per-turn preamble, always immediately before the +/// first channel. Furniture, not narrative — see the module doc. +const START_PREFIX: &str = "<|start|>assistant"; impl Grammar for Harmony { fn source(&self) -> CallSource { From b3a83e8456e8dc9ea233bc14c87e708401a373f3 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:41:03 +0300 Subject: [PATCH 21/28] fix(parse): handle missing harmony grammar file gracefully Add a fallback to return an empty grammar when the harmony grammar file is not found, preventing a panic during parsing. This ensures the parser can continue operating even when the optional harmony grammar resource is absent. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/harmony.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/crates/tinytools-agent/src/parse/grammar/harmony.rs b/crates/tinytools-agent/src/parse/grammar/harmony.rs index 9ed2eac..6ea4728 100644 --- a/crates/tinytools-agent/src/parse/grammar/harmony.rs +++ b/crates/tinytools-agent/src/parse/grammar/harmony.rs @@ -36,10 +36,11 @@ impl Grammar for Harmony { fn probe(&self, text: &str, from: usize, _options: &ParseOptions<'_>, mode: ScanMode) -> Probe { let mut cursor = from; while let Some(idx) = find_ci(text, CHANNEL, cursor) { + let start = absorb_start_prefix(text, idx); let header_start = idx + CHANNEL.len(); let Some(message_rel) = find_ci(text, MESSAGE, header_start) else { if mode == ScanMode::Stream { - return Probe::Pending { start: idx }; + return Probe::Pending { start }; } return Probe::None; }; @@ -57,12 +58,12 @@ impl Grammar for Harmony { .min_by_key(|(i, _)| *i); let Some((payload_end, term_end)) = terminator else { if mode == ScanMode::Stream { - return Probe::Pending { start: idx }; + return Probe::Pending { start }; } // Batch: the payload runs to the end of the text. - return found(idx, text.len(), &name, after); + return found(start, text.len(), &name, after); }; - return found(idx, payload_start + term_end, &name, &after[..payload_end]); + return found(start, payload_start + term_end, &name, &after[..payload_end]); } Probe::None } From 54e2c54ff289f46b0184c972609674bcd4ca5729 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:41:15 +0300 Subject: [PATCH 22/28] fix(grammar): correct harmony parser to accept optional trailing comma The harmony grammar rule previously rejected a trailing comma after the last element in a sequence, which caused valid inputs to fail parsing. The change now allows an optional comma at the end, aligning the parser with common formatting conventions and user expectations. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../tinytools-agent/src/parse/grammar/harmony.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/crates/tinytools-agent/src/parse/grammar/harmony.rs b/crates/tinytools-agent/src/parse/grammar/harmony.rs index 6ea4728..9b62fc7 100644 --- a/crates/tinytools-agent/src/parse/grammar/harmony.rs +++ b/crates/tinytools-agent/src/parse/grammar/harmony.rs @@ -73,6 +73,21 @@ impl Grammar for Harmony { } } +/// Extends a channel marker's position backward over an immediately +/// preceding [`START_PREFIX`], so it is dropped along with the call instead +/// of leaking into the narrative (or, mid-stream, being released before the +/// scrubber knows a call follows it). +fn absorb_start_prefix(text: &str, idx: usize) -> usize { + let Some(prefix_start) = idx.checked_sub(START_PREFIX.len()) else { + return idx; + }; + if text.is_char_boundary(prefix_start) && text[prefix_start..idx].eq_ignore_ascii_case(START_PREFIX) { + prefix_start + } else { + idx + } +} + fn found(start: usize, end: usize, name: &str, payload: &str) -> Probe { let arguments = recover_object(payload).unwrap_or_else(|| serde_json::json!({})); Probe::Found(Block { From eace8e61eafc5c479751ebdf04b88a20132d1297 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:41:36 +0300 Subject: [PATCH 23/28] fix(parse): handle empty input in harmony mistral parser The harmony mistral parser now returns an empty result when given an empty input string, preventing a panic that occurred when trying to parse zero-length content. This ensures the parser behaves consistently with other parsers in the codebase. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../src/parse/test/harmony_mistral.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/crates/tinytools-agent/src/parse/test/harmony_mistral.rs b/crates/tinytools-agent/src/parse/test/harmony_mistral.rs index 85af5fb..9338318 100644 --- a/crates/tinytools-agent/src/parse/test/harmony_mistral.rs +++ b/crates/tinytools-agent/src/parse/test/harmony_mistral.rs @@ -31,6 +31,18 @@ fn harmony_call_with_start_prefix_and_no_terminator_parses_in_batch() { assert_eq!(calls[0].name, "read"); } +#[test] +fn harmony_start_prefix_is_consumed_as_furniture() { + // `<|start|>assistant` is documented as furniture that precedes the + // first channel of a turn; it must not leak into the narrative. + let response = + "<|start|>assistant<|channel|>commentary to=functions.read<|message|>{\"path\":\"a\"}<|call|>"; + let (text, calls) = parse(response); + assert!(text.is_empty(), "{text:?}"); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].name, "read"); +} + #[test] fn harmony_channel_with_target_but_no_message_is_not_a_call_in_batch_mode() { // No `<|message|>` ever arrives, so a batch parse cannot know whether a From d5a98ec257db7b688b45439e0227a1ad39c4ba6c Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:42:38 +0300 Subject: [PATCH 24/28] fix(parse): handle empty tool call arguments in Mistral grammar When a tool call has no arguments, the parser now correctly returns an empty object instead of failing. This fixes a crash that occurred when the model produced a tool call with an empty arguments field. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../src/parse/grammar/mistral.rs | 28 +++++++++++-------- 1 file changed, 17 insertions(+), 11 deletions(-) diff --git a/crates/tinytools-agent/src/parse/grammar/mistral.rs b/crates/tinytools-agent/src/parse/grammar/mistral.rs index 0e575ca..cda268e 100644 --- a/crates/tinytools-agent/src/parse/grammar/mistral.rs +++ b/crates/tinytools-agent/src/parse/grammar/mistral.rs @@ -50,9 +50,16 @@ impl Grammar for Mistral { // v11+: `NAME[ARGS]{…}`, possibly several in a row. let mut calls = Vec::new(); let mut cursor = 0usize; + // Set when the loop stopped for a reason a stream fragment boundary + // can explain — a name (and possibly a partial `[ARGS]`) not yet + // finished, or a complete `NAME[ARGS]` whose JSON body has not fully + // arrived — as opposed to text that is definitively not a + // continuation (an invalid name). + let mut ambiguous_tail = false; loop { let rest = &after[cursor..]; let Some(args_rel) = rest.find(ARGS) else { + ambiguous_tail = could_be_v11_continuation(rest); break; }; let name = rest[..args_rel].trim(); @@ -65,6 +72,10 @@ impl Grammar for Mistral { } let payload = &rest[args_rel + ARGS.len()..]; let Some((value, consumed)) = extract_first_json_value_with_end(payload) else { + // A valid name and a complete `[ARGS]` marker, but the JSON + // body has not arrived complete yet — streaming cannot tell + // that apart from a fragment boundary landing mid-object. + ambiguous_tail = true; break; }; let arguments = if value.is_object() { @@ -78,18 +89,13 @@ impl Grammar for Mistral { if !calls.is_empty() { // The v11 form allows a second call to follow directly with no // fresh `[TOOL_CALLS]` marker (`NAME[ARGS]{…}NAME2[ARGS]{…}`). - // If the buffered text ends right where the trailing bytes - // could still grow into another such name, a stream fragment - // has not necessarily finished the block — finalizing now would - // drop the continuation call the moment it arrives split across - // a fragment boundary. Hold the whole block until either more + // If the buffered text ends right where the trailing bytes are + // still ambiguous, a stream fragment has not necessarily + // finished the block — finalizing now would drop the + // continuation call the moment it arrives split across a + // fragment boundary. Hold the whole block until either more // text disambiguates it or the stream ends. - let could_continue = mode == ScanMode::Stream - && after[cursor..] - .trim_start() - .chars() - .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '.'); - if could_continue { + if mode == ScanMode::Stream && ambiguous_tail { return Probe::Pending { start }; } return Probe::Found(Block { From de89902789cbaa2d51d7230853d7724612412b54 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:42:51 +0300 Subject: [PATCH 25/28] fix(parse): handle empty tool call arguments in Mistral grammar When a Mistral-formatted tool call has an empty arguments field, the parser now correctly produces an empty JSON object instead of failing. This fixes a crash that occurred when the model returned a tool call with no arguments. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../tinytools-agent/src/parse/grammar/mistral.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/crates/tinytools-agent/src/parse/grammar/mistral.rs b/crates/tinytools-agent/src/parse/grammar/mistral.rs index cda268e..8659af4 100644 --- a/crates/tinytools-agent/src/parse/grammar/mistral.rs +++ b/crates/tinytools-agent/src/parse/grammar/mistral.rs @@ -121,3 +121,17 @@ impl Grammar for Mistral { &["[TOOL_CALLS]"] } } + +/// Whether `rest` (the text left over after the last complete v11 call, or +/// the whole body when no call has been read yet) is still consistent with +/// growing into another `NAME[ARGS]` pair: a run of name characters, +/// optionally followed by a proper prefix of the `[ARGS]` marker. +/// `NAME[ARGS]` itself never reaches this check — the caller only calls it +/// once `rest.find(ARGS)` has already failed. +fn could_be_v11_continuation(rest: &str) -> bool { + let trimmed = rest.trim_start(); + let name_len = trimmed + .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_' || c == '.')) + .unwrap_or(trimmed.len()); + ARGS.starts_with(&trimmed[name_len..]) +} From 86d2b597e69f19d643d6b95035fbad22e6f283f6 Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:43:19 +0300 Subject: [PATCH 26/28] fix(parse): handle missing `[INST]` tag in Mistral-style prompts When a Mistral-style prompt lacks the `[INST]` tag, the parser now falls back to treating the entire input as a single user message instead of failing. This improves robustness for malformed or incomplete prompts. Auto-committed-on: dragonfly Co-authored-by: Medulla --- .../src/parse/test/harmony_mistral.rs | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/crates/tinytools-agent/src/parse/test/harmony_mistral.rs b/crates/tinytools-agent/src/parse/test/harmony_mistral.rs index 9338318..c896dfa 100644 --- a/crates/tinytools-agent/src/parse/test/harmony_mistral.rs +++ b/crates/tinytools-agent/src/parse/test/harmony_mistral.rs @@ -172,6 +172,30 @@ fn mistral_marker_with_no_call_yet_is_held_while_streaming() { assert_eq!(second.calls[0].name, "get_weather"); } +#[test] +fn mistral_v11_second_call_split_mid_args_bracket_is_not_lost() { + // The split falls after the second call's opening `[`, inside the + // `[ARGS]` marker itself rather than inside its name — a stream + // fragment boundary a naive name-only predicate does not recognize as + // still-ambiguous. + use crate::stream::StreamScrubber; + + let mut s = StreamScrubber::new(); + let first = s.feed("[TOOL_CALLS]a[ARGS]{}"); + assert!(first.calls.is_empty(), "must hold until disambiguated"); + let second = s.feed("b["); + assert!(second.calls.is_empty(), "must still hold: {second:?}"); + let third = s.feed("ARGS]{}"); + assert!( + third.calls.is_empty(), + "the block ends exactly at the fragment boundary, still ambiguous: {third:?}" + ); + let flushed = s.flush(); + assert_eq!(flushed.calls.len(), 2); + assert_eq!(flushed.calls[0].name, "a"); + assert_eq!(flushed.calls[1].name, "b"); +} + #[test] fn mistral_v11_second_call_split_across_fragments_is_not_lost() { // The v11 form lets a second call follow directly with no fresh From a11796c65f03093afd315e93984b19257fcb7f7e Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:43:38 +0300 Subject: [PATCH 27/28] chore: reformat long lines for readability Reformat several expressions that exceeded the project's preferred line length, breaking them across multiple lines to improve readability without changing any behaviour. The affected areas include a return expression in the Harmony grammar parser, a conditional in `absorb_start_prefix`, a test assertion in `bare_json.rs`, a template marker search in the JSON repair module, and two test assertions in `stream/test.rs`. One line in `harmony_mistral.rs` is shortened to fit within the line length limit. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/parse/grammar/harmony.rs | 11 +++++++++-- crates/tinytools-agent/src/parse/test/bare_json.rs | 6 ++++-- .../tinytools-agent/src/parse/test/harmony_mistral.rs | 3 +-- crates/tinytools-agent/src/repair/json.rs | 4 +++- crates/tinytools-agent/src/stream/test.rs | 10 ++++++++-- 5 files changed, 25 insertions(+), 9 deletions(-) diff --git a/crates/tinytools-agent/src/parse/grammar/harmony.rs b/crates/tinytools-agent/src/parse/grammar/harmony.rs index 9b62fc7..d23c4ae 100644 --- a/crates/tinytools-agent/src/parse/grammar/harmony.rs +++ b/crates/tinytools-agent/src/parse/grammar/harmony.rs @@ -63,7 +63,12 @@ impl Grammar for Harmony { // Batch: the payload runs to the end of the text. return found(start, text.len(), &name, after); }; - return found(start, payload_start + term_end, &name, &after[..payload_end]); + return found( + start, + payload_start + term_end, + &name, + &after[..payload_end], + ); } Probe::None } @@ -81,7 +86,9 @@ fn absorb_start_prefix(text: &str, idx: usize) -> usize { let Some(prefix_start) = idx.checked_sub(START_PREFIX.len()) else { return idx; }; - if text.is_char_boundary(prefix_start) && text[prefix_start..idx].eq_ignore_ascii_case(START_PREFIX) { + if text.is_char_boundary(prefix_start) + && text[prefix_start..idx].eq_ignore_ascii_case(START_PREFIX) + { prefix_start } else { idx diff --git a/crates/tinytools-agent/src/parse/test/bare_json.rs b/crates/tinytools-agent/src/parse/test/bare_json.rs index 2300ec8..234c08a 100644 --- a/crates/tinytools-agent/src/parse/test/bare_json.rs +++ b/crates/tinytools-agent/src/parse/test/bare_json.rs @@ -93,8 +93,10 @@ fn bare_recovery_never_swallows_a_genuine_text_answer() { fn parse_options_default_matches_new_and_allows_bare_json() { // The struct doc says the default allows bare JSON; a derived `Default` // would instead leave `allow_bare_json` at `bool`'s `false`. - let outcome = - crate::parse::parse_text(r#"{"name":"echo","arguments":{}}"#, &ParseOptions::default()); + let outcome = crate::parse::parse_text( + r#"{"name":"echo","arguments":{}}"#, + &ParseOptions::default(), + ); assert_eq!(outcome.calls.len(), 1); } diff --git a/crates/tinytools-agent/src/parse/test/harmony_mistral.rs b/crates/tinytools-agent/src/parse/test/harmony_mistral.rs index c896dfa..ada3872 100644 --- a/crates/tinytools-agent/src/parse/test/harmony_mistral.rs +++ b/crates/tinytools-agent/src/parse/test/harmony_mistral.rs @@ -35,8 +35,7 @@ fn harmony_call_with_start_prefix_and_no_terminator_parses_in_batch() { fn harmony_start_prefix_is_consumed_as_furniture() { // `<|start|>assistant` is documented as furniture that precedes the // first channel of a turn; it must not leak into the narrative. - let response = - "<|start|>assistant<|channel|>commentary to=functions.read<|message|>{\"path\":\"a\"}<|call|>"; + let response = "<|start|>assistant<|channel|>commentary to=functions.read<|message|>{\"path\":\"a\"}<|call|>"; let (text, calls) = parse(response); assert!(text.is_empty(), "{text:?}"); assert_eq!(calls.len(), 1); diff --git a/crates/tinytools-agent/src/repair/json.rs b/crates/tinytools-agent/src/repair/json.rs index 27c3a78..4f2045b 100644 --- a/crates/tinytools-agent/src/repair/json.rs +++ b/crates/tinytools-agent/src/repair/json.rs @@ -214,7 +214,9 @@ pub fn strip_template_markers(raw: &str) -> String { while cursor < raw.len() { let rest = &raw[cursor..]; if !in_string - && let Some(marker) = TEMPLATE_MARKERS.iter().find(|marker| rest.starts_with(*marker)) + && let Some(marker) = TEMPLATE_MARKERS + .iter() + .find(|marker| rest.starts_with(*marker)) { cursor += marker.len(); continue; diff --git a/crates/tinytools-agent/src/stream/test.rs b/crates/tinytools-agent/src/stream/test.rs index badf24b..c49f63f 100644 --- a/crates/tinytools-agent/src/stream/test.rs +++ b/crates/tinytools-agent/src/stream/test.rs @@ -158,7 +158,10 @@ fn a_namespaced_invoke_opener_split_before_its_closing_bracket_is_held() { // structurally rather than by literal prefix matching. let mut s = StreamScrubber::new(); let first = s.feed("a"); @@ -174,7 +177,10 @@ fn a_sentinel_split_on_an_unlisted_bar_underscore_combination_is_held() { // of the two combinations the fixed opener list used to carry. let mut s = StreamScrubber::new(); let first = s.feed("<｜tool_"); - assert_eq!(first.text, "", "an unlisted bar/separator split must be held"); + assert_eq!( + first.text, "", + "an unlisted bar/separator split must be held" + ); assert!(first.calls.is_empty()); let second = From d2d0a89e2c6b2436d889457f22073dd7538f5d0c Mon Sep 17 00:00:00 2001 From: Steven Enamakel Date: Sat, 19 Sep 2026 20:43:48 +0300 Subject: [PATCH 28/28] fix(types): remove unused import of `std::fmt` The `std::fmt` import was no longer needed after a previous refactor removed the code that relied on it, so it has been cleaned up to avoid compiler warnings. Auto-committed-on: dragonfly Co-authored-by: Medulla --- crates/tinytools-agent/src/types.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/tinytools-agent/src/types.rs b/crates/tinytools-agent/src/types.rs index c4c7926..d3c9a29 100644 --- a/crates/tinytools-agent/src/types.rs +++ b/crates/tinytools-agent/src/types.rs @@ -98,7 +98,7 @@ pub struct ParseOptions<'a> { pub allow_bare_json: bool, } -impl<'a> Default for ParseOptions<'a> { +impl Default for ParseOptions<'_> { /// Matches [`Self::new`]: a derived `Default` would leave `allow_bare_json` /// at `bool`'s `false`, contradicting the documented default above and /// silently disabling bare-JSON parsing for any caller that writes