Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.
C++
serve: a call returned as text for an undeclared name is named in the reply; the collapsed mcp__a__b spelling is the declared tool (#3796)
Niko1221805ebe17be37
diff --git a/docs/DETAILS.md b/docs/DETAILS.mdindex f60429bf2..29dcefd82 100644--- a/docs/DETAILS.md+++ b/docs/DETAILS.md@@ -483,9 +483,20 @@ applies at the next start. Network, key, MCP and program keys are not editable tevery 15 s and `GET /status` says what it is doing. Closing the connection or pressing stop in your app stops the model.- A tool call counts only when it names a tool the request declared. A namespaced tool (`mcp__filesystem.write_file`) isthat call when the model writes `mcp__filesystem__write_file`, `mcp__filesystem=write_file`, `mcp__filesystem_write_file`,- or the bare member (`write_file`) and exactly one declared tool has that member. Any other call, or any call in a request- that declared no tools, comes back as the text it was written as. A call whose envelope drifted by a token (`<=NAME>`,+ or the bare member (`write_file`) and exactly one declared tool has that member. A name with `__` in it (`mcp__playwright__browser_navigate`)+ is also that call when the model writes every `__` as `_` (`mcp_playwright_browser_navigate`), unless two declared tools collapse to the same+ spelling. Any other call, or any call in a request that declared no tools, comes back as the text it was written as. Names are never+ guessed: `bash` is not `shell`, and a reordered name (`server1_label_values` for `label_values_mcp_server1`) is not the declared one.+ A call whose envelope drifted by a token (`<=NAME>`,`<function:NAME>` or `<NAME>` instead of `<function=NAME>`) is read as the call when NAME is a declared tool.+- **A call that came back as text because its name was not declared (#3796).** The text stays exactly as the model wrote it and+ `finish_reason` stays `stop` (or `end_turn` on `/v1/messages`). Next to it the reply carries a list, only when there is something in it:+ `"strata_rejected_tool_calls": [{"name": "bash", "reason": "undeclared"}]` (at the top level of a Chat Completions reply, in+ its last streamed chunk, and in the `message_delta` event and the message of `/v1/messages`; up to five names). A client that+ wants to recover can answer the model with the tool names it does have and ask again; Strata never runs or forwards a call for a+ tool the request did not declare. The server window prints the same names (`N <tool_call> block(s) ... went back as text`), and+ `/metrics/prometheus` counts the blocks in `strata:tool_calls_unread_total`. A block that is malformed (not an undeclared name) is counted+ there and in the window, but has no name to list.- JSON output: `response_format: {"type":"json_object"}` or `{"type":"json_schema", ...}` on `/v1/chat/completions`. The schemamust accept only JSON objects at its root (`"type":"object"`, or `anyOf`/`oneOf` of object schemas). Local `#` referenceswork and remote ones are refused. This is schema prompting followed by server validation, not grammar-constraineddiff --git a/serve/frontend.py b/serve/frontend.pyindex 0d00ded47..d4bac5d79 100644--- a/serve/frontend.py+++ b/serve/frontend.py@@ -935,6 +935,12 @@ class OutputParser:for alias in (f"{namespace}__{member}", f"{namespace}={member}",f"{namespace}_{member}", member):aliases.setdefault(alias, set()).add(name)+ # #3796: the same tool written with every `__` collapsed to `_` (`mcp__playwright__browser_navigate` as+ # `mcp_playwright_browser_navigate`, the way Qwen often flattens a name) is that tool. Only a spelling of a declared+ # name: a reordered or renamed tool (`server1_label_values` for `label_values_mcp_server1`) is not guessed.+ for name in self.schemas:+ if isinstance(name, str) and "__" in name:+ aliases.setdefault(name.replace("__", "_"), set()).add(name)self.aliases = {alias: next(iter(names)) for alias, names in aliases.items()if len(names) == 1 and alias not in self.schemas}self.unread = 0 # #3441: `<tool_call>` blocks that opened like a call and were returned as textdiff --git a/serve/server.py b/serve/server.pyindex 76b5a2c79..0ce1942c0 100644--- a/serve/server.py+++ b/serve/server.py@@ -4680,6 +4680,8 @@ class Service:("strata:requests_total", "counter", "Requests finished", t["requests"]),("strata:drafts_offered_total", "counter", "Speculative draft tokens offered", t["drafts_offered"]),("strata:drafts_accepted_total", "counter", "Speculative draft tokens accepted", t["drafts_accepted"]),+ ("strata:tool_calls_unread_total", "counter", "<tool_call> blocks returned as text (an undeclared name or a form the template does not use)",+ t.get("tool_calls_unread", 0)),("strata:model_loaded", "gauge", "1 while the model is loaded", int(self.loaded())),]return "".join(f"# HELP {name} {help_}\n# TYPE {name} {kind}\n{name} {value}\n"@@ -5596,11 +5598,17 @@ class Service:self.totals["tool_calls_from_reasoning"] = self.totals.get("tool_calls_from_reasoning", 0) + parser.rescuedprint(f"[strata] tool calls inside the thinking: {parser.rescued} read as calls, {parser.refused} kept as "f"reasoning (quoted, or the turn did not end on a stop)", flush=True)+ rejected = []if parser.unread:named = getattr(parser, "unread_names", None)print(f"[strata] {parser.unread} <tool_call> block(s) in the answer did not read as a call of a declared ""tool and went back as text (a name the request did not declare, or a form the template does "- "not use)" + (f"; the names the model wrote: {', '.join(named)}" if named else ""), flush=True)+ "not use)" + (f"; the names the model wrote: {', '.join(named)}" if named else "")+ + "; the response carries them as strata_rejected_tool_calls, /metrics counts them", flush=True)+ with self.status_lock:+ self.totals["tool_calls_unread"] = self.totals.get("tool_calls_unread", 0) + parser.unread+ # #3796: the same names for the client (a machine-readable marker next to the text, which stays as the model wrote it)+ rejected = [{"name": nm, "reason": "undeclared"} for nm in named or []]if stops is not None and stops.hit is None and stops.held:yield "event", Event("content", stops.flush()) # the held tail was not a stop string after alldone = {"finish": finish, "completion_tokens": n, "reused": (timings or {}).get("cache_n", 0),@@ -5608,6 +5616,8 @@ class Service:"reasoning_recoveries": recovery_count}if stops is not None and stops.hit is not None:done["stop_sequence"] = stops.hit+ if rejected:+ done["rejected_tool_calls"] = rejectedyield "done", done@@ -5892,6 +5902,8 @@ def openai_chunks(svc: Service, req: dict, ids, thinking, tools, max_new, cancel"prompt_tokens_details": {"cached_tokens": x.get("reused") or 0}}if x.get("timings"):last["timings"] = x["timings"] # llama.cpp's field: the speed its clients show+ if x.get("rejected_tool_calls"):+ last["strata_rejected_tool_calls"] = x["rejected_tool_calls"] # #3796: only when a call was refused as undeclaredyield last@@ -5938,6 +5950,8 @@ def openai_collect(chunks) -> dict:"usage": last["usage"]}if last.get("timings"):out["timings"] = last["timings"]+ if last.get("strata_rejected_tool_calls"):+ out["strata_rejected_tool_calls"] = last["strata_rejected_tool_calls"]return out@@ -6029,11 +6043,12 @@ def anthropic_events(svc: Service, req: dict, ids, thinking, tools, max_new, can# request, a cache write; input_tokens keeps the last token, as 0 makes Claude Code count the prompt twice (#1013)reused = max(0, min(x.get("reused") or 0, len(ids) - 1))read_now = len(ids) - reused- yield "message_delta", {"type": "message_delta", "delta": {"stop_reason": stop,- "stop_sequence": x.get("stop_sequence")},- "usage": {"input_tokens": 1, "cache_creation_input_tokens": read_now - 1,- "cache_read_input_tokens": reused,- "output_tokens": x["completion_tokens"]}}+ delta_event = {"type": "message_delta", "delta": {"stop_reason": stop, "stop_sequence": x.get("stop_sequence")},+ "usage": {"input_tokens": 1, "cache_creation_input_tokens": read_now - 1,+ "cache_read_input_tokens": reused, "output_tokens": x["completion_tokens"]}}+ if x.get("rejected_tool_calls"):+ delta_event["strata_rejected_tool_calls"] = x["rejected_tool_calls"] # #3796+ yield "message_delta", delta_eventyield "message_stop", {"type": "message_stop"}@@ -6065,6 +6080,8 @@ def anthropic_collect(events) -> dict:msg["stop_reason"] = e["delta"]["stop_reason"]msg["stop_sequence"] = e["delta"].get("stop_sequence")msg["usage"].update(e["usage"])+ if e.get("strata_rejected_tool_calls"):+ msg["strata_rejected_tool_calls"] = e["strata_rejected_tool_calls"]for i in range(len(blocks) - 1): # a turn with no </think> (serve/dsml.py): the text is the answer; it is not also a thinking blocka, b = blocks[i], blocks[i + 1]if a.get("type") == "thinking" and b.get("type") == "text" and a.get("thinking", "").strip() == b.get("text", "").strip():diff --git a/serve/test_server.py b/serve/test_server.pyindex 3e60dee4e..7babcde15 100644--- a/serve/test_server.py+++ b/serve/test_server.py@@ -4521,6 +4521,74 @@ class ForcedToolChoice(unittest.TestCase):self.assertIn("Here is the report.", content)self.assertIn("<function=lookup>", content)+ def _undeclared_call_answer(self, name="lookup"):+ from serve.frontend import CALL_END, CALL_START+ return ("I will check that.\n" + CALL_START + f"\n<function={name}>\n<parameter=q>\n2+2\n</parameter>\n"+ "</function>\n" + CALL_END)++ def _rejected_of(self, b, stream):+ """The strata_rejected_tool_calls of a whole reply or of a streamed one (None when the reply has none)."""+ if not stream:+ return b.get("strata_rejected_tool_calls")+ found = [json.loads(line[6:]).get("strata_rejected_tool_calls") for line in b.splitlines() if line.startswith("data: {")]+ found = [f for f in found if f]+ self.assertLessEqual(len(found), 1, "sent once, with the last chunk")+ return found[0] if found else None++ def test_an_undeclared_call_is_named_in_the_response(self):+ """#3796: the call stays text and finish_reason stays "stop"; the response also lists the names the model wrote+ (strata_rejected_tool_calls), so a client can tell this from an ordinary answer and answer the model."""+ self.says(self._undeclared_call_answer("execute_gdscript"))+ for stream in (False, True):+ with self.subTest(stream=stream):+ before = self.svc.totals.get("tool_calls_unread", 0)+ code, b = self.openai(stream=stream)+ finish, calls, _ = self.call_of(code, b, stream)+ self.assertEqual((finish, calls), ("stop", []), b)+ self.assertEqual(self._rejected_of(b, stream), [{"name": "execute_gdscript", "reason": "undeclared"}])+ self.assertEqual(self.svc.totals["tool_calls_unread"], before + 1) # /metrics counts it+ if not stream:+ self.assertIn("<function=execute_gdscript>", b["choices"][0]["message"]["content"]) # the text is untouched++ def test_no_marker_when_nothing_was_rejected(self):+ """An ordinary answer and a declared call carry no extra field: the API is what it was."""+ from serve.frontend import CALL_END, CALL_START+ for label, answer in (("text", "The answer is 4."),+ ("declared call", CALL_START + "\n<function=search>\n<parameter=q>\n2+2\n</parameter>\n</function>\n" + CALL_END)):+ self.says(answer)+ for stream in (False, True):+ with self.subTest(case=label, stream=stream):+ code, b = self.openai(stream=stream)+ self.call_of(code, b, stream)+ self.assertIsNone(self._rejected_of(b, stream))+ if stream:+ self.assertNotIn("strata_rejected_tool_calls", b)++ def test_a_collapsed_mcp_name_is_a_call_not_a_rejection(self):+ """#3796: `mcp_playwright_browser_navigate` for the declared `mcp__playwright__browser_navigate`."""+ from serve.frontend import CALL_END, CALL_START+ tools = [{"type": "function", "function": {"name": "mcp__playwright__browser_navigate", "description": "open a page",+ "parameters": {"type": "object", "properties": {"q": {"type": "string"}}}}}]+ self.says(CALL_START + "\n<function=mcp_playwright_browser_navigate>\n<parameter=q>\nx\n</parameter>\n</function>\n" + CALL_END)+ for stream in (False, True):+ with self.subTest(stream=stream):+ code, b = self.openai(stream=stream, tools=tools)+ finish, calls, _ = self.call_of(code, b, stream)+ self.assertEqual((finish, calls), ("tool_calls", [("mcp__playwright__browser_navigate", {"q": "x"})]))+ self.assertIsNone(self._rejected_of(b, stream))++ def test_the_anthropic_reply_names_the_rejected_call_too(self):+ self.says(self._undeclared_call_answer("bash"))+ body = {"model": "m", "max_tokens": 400, "messages": [{"role": "user", "content": "2+2?"}],+ "tools": [{"name": "search", "description": "search", "input_schema": {"type": "object", "properties": {}}}]}+ req = urllib.request.Request(self.base + "/v1/messages", data=json.dumps(body).encode(),+ headers={"Content-Type": "application/json"})+ with urllib.request.urlopen(req, timeout=30) as r:+ msg = json.loads(r.read().decode())+ self.assertEqual(msg["stop_reason"], "end_turn")+ self.assertEqual(msg["strata_rejected_tool_calls"], [{"name": "bash", "reason": "undeclared"}])+ self.assertFalse([c for c in msg["content"] if c["type"] == "tool_use"])+def test_a_call_with_a_dropped_function_keyword_is_still_the_call(self):"""#3441: `<=search>` for `<function=search>`, as a model under a large tool surface writes it."""from serve.frontend import CALL_END, CALL_STARTdiff --git a/serve/test_tool_name_alias.py b/serve/test_tool_name_alias.pyindex 1ceda8b86..5efc83657 100644--- a/serve/test_tool_name_alias.py+++ b/serve/test_tool_name_alias.py@@ -193,5 +193,69 @@ class DriftedMcpNames(unittest.TestCase):self.assertNotIn("namespace", calls[0])+def plain_tool(name):+ return {"name": name, "parameters": {"type": "object", "properties": {"url": {"type": "string"}}}}+++def call_text(name, param="url", value="https://example.com"):+ return f"<tool_call>\n<function={name}>\n<parameter={param}>\n{value}\n</parameter>\n</function>\n</tool_call>"+++def run_parser(text, tools, width=0):+ parser = OutputParser(thinking=False, tools=tools, stream_tools=True, declared_only=True)+ evs = []+ step = width or len(text) or 1+ for k in range(0, len(text), step):+ evs += parser.feed(text[k:k + step])+ evs += parser.finish("stop")+ return evs, parser+++class CollapsedUnderscoreNames(unittest.TestCase):+ """#3796: `mcp__server__tool` written as `mcp_server_tool` is a spelling of the declared tool (the same class of+ difference as namespace__member). A name that is only similar stays text, and is named for the client."""+ MCP = [plain_tool("mcp__playwright__browser_navigate"), plain_tool("mcp__playwright__browser_snapshot"),+ plain_tool("mcp__playwright__browser_tabs"), plain_tool("todo_write")]++ def test_the_collapsed_spelling_is_the_declared_tool(self):+ for name in ("browser_navigate", "browser_snapshot", "browser_tabs"):+ for width in (0, 1, 5):+ with self.subTest(name=name, width=width):+ evs, parser = run_parser("Opening it.\n" + call_text("mcp_playwright_" + name), self.MCP, width)+ found = [e.call for e in evs if e.kind == "tool_call"]+ self.assertEqual([c.name for c in found], ["mcp__playwright__" + name]) # the client gets the name it declared+ self.assertEqual(found[0].arguments, {"url": "https://example.com"})+ self.assertEqual(text_of(evs).strip(), "Opening it.")+ self.assertEqual((parser.unread, parser.unread_names), (0, []))++ def test_the_declared_spelling_and_a_plain_tool_are_unchanged(self):+ evs, _ = run_parser(call_text("mcp__playwright__browser_tabs") + "\n" + call_text("todo_write"), self.MCP)+ self.assertEqual([e.call.name for e in evs if e.kind == "tool_call"], ["mcp__playwright__browser_tabs", "todo_write"])++ def test_a_tool_declared_in_the_collapsed_spelling_wins(self):+ tools = self.MCP + [plain_tool("mcp_playwright_browser_tabs")]+ evs, _ = run_parser(call_text("mcp_playwright_browser_tabs"), tools)+ self.assertEqual([e.call.name for e in evs if e.kind == "tool_call"], ["mcp_playwright_browser_tabs"])++ def test_two_tools_with_the_same_collapsed_spelling_are_not_guessed(self):+ tools = [plain_tool("a__b_c"), plain_tool("a_b__c")]+ evs, parser = run_parser(call_text("a_b_c"), tools)+ self.assertEqual([e for e in evs if e.kind == "tool_call"], [])+ self.assertIn("a_b_c", text_of(evs))+ self.assertEqual(parser.unread_names, ["a_b_c"])++ def test_a_reordered_or_renamed_tool_stays_text_and_is_named(self):+ """The LibreChat case (`server1_label_values` for `label_values_mcp_server1`) and the bash/shell case: no guessing."""+ for declared, written in (("label_values_mcp_server1", "server1_label_values"), ("shell", "bash"),+ ("godot_execute_gdscript", "execute_gdscript")):+ for width in (0, 3):+ with self.subTest(written=written, width=width):+ raw = "Done.\n" + call_text(written)+ evs, parser = run_parser(raw, [plain_tool(declared)], width)+ self.assertEqual([e for e in evs if e.kind == "tool_call"], [])+ self.assertEqual(text_of(evs), raw) # the text is exactly what the model wrote+ self.assertEqual((parser.unread, parser.unread_names), (1, [written]))++if __name__ == "__main__":unittest.main()