Skip to content

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: accept Codex spellings of a namespace tool (#3972)

Righteous-AIfd8d37e93db2
diff --git a/docs/DETAILS.md b/docs/DETAILS.md
index 43538ddca..f60429bf2 100644
--- a/docs/DETAILS.md
+++ b/docs/DETAILS.md
@@ -481,9 +481,11 @@ applies at the next start. Network, key, MCP and program keys are not editable t
- With `"stream": true` everything arrives as it is made: thinking, answer and tool calls (the tool's name first, then its
arguments piece by piece). While the model reads a long prompt the stream sends keep-alives. The server window prints progress
every 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. 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>`, `<function:NAME>`
- or `<NAME>` instead of `<function=NAME>`) is read as the call when NAME is a declared tool.
+- A tool call counts only when it names a tool the request declared. A namespaced tool (`mcp__filesystem.write_file`) is
+ that 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>`,
+ `<function:NAME>` or `<NAME>` instead of `<function=NAME>`) is read as the call when NAME is a declared tool.
- JSON output: `response_format: {"type":"json_object"}` or `{"type":"json_schema", ...}` on `/v1/chat/completions`. The schema
must accept only JSON objects at its root (`"type":"object"`, or `anyOf`/`oneOf` of object schemas). Local `#` references
work and remote ones are refused. This is schema prompting followed by server validation, not grammar-constrained
diff --git a/serve/frontend.py b/serve/frontend.py
index a70494f08..0d00ded47 100644
--- a/serve/frontend.py
+++ b/serve/frontend.py
@@ -923,14 +923,18 @@ class OutputParser:
# the client has no tool to run). The Responses route leaves it off: a Codex compaction request keeps its
# conversation's tools in the prompt only, and its calls come back as before.
self.declared_only = declared_only
- # PR #3556: the native namespace__member spelling of a declared namespace.member tool is accepted without advertising a
- # duplicate tool. Only an unambiguous alias counts (two namespaces can end in the same member), and an exactly declared
+ # A declared namespace.member tool is also accepted as namespace__member (PR #3556),
+ # namespace=member (Qwen writes the <function= tag's equals sign into the name),
+ # namespace_member (one underscore dropped), and the bare member when exactly one
+ # declared tool has it. Only an unambiguous alias counts, and an exactly declared
# name always wins over an alias.
aliases = {}
for name in self.schemas:
if isinstance(name, str) and "." in name:
namespace, member = name.rsplit(".", 1)
- aliases.setdefault(f"{namespace}__{member}", set()).add(name)
+ for alias in (f"{namespace}__{member}", f"{namespace}={member}",
+ f"{namespace}_{member}", member):
+ aliases.setdefault(alias, 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 text
diff --git a/serve/test_tool_name_alias.py b/serve/test_tool_name_alias.py
new file mode 100644
index 000000000..1ceda8b86
--- /dev/null
+++ b/serve/test_tool_name_alias.py
@@ -0,0 +1,197 @@
+"""Codex MCP names that are not the declared namespace.member form.
+
+Observed with Qwen3.8-Flash-Next through Codex CLI against Strata v0.2.2. The model
+wrote <function=mcp__filesystem=write_file>, <function=mcp__filesystem_edit_file>,
+and later a bare <function=write_file>. The declared tool was
+mcp__filesystem.write_file. Stock main already accepts namespace__member. The
+equals sign, the dropped underscore, and a unique bare member have to as well.
+A name that matches nothing stays text (#3075). Two tools that share a member
+are not guessed.
+
+ python -m unittest serve.test_tool_name_alias -v
+"""
+import json
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from serve.frontend import OutputParser # noqa: E402
+from serve.responses import Assembler, request_tools # noqa: E402
+
+REQ = {
+ "tools": [{
+ "type": "namespace",
+ "name": "mcp__filesystem",
+ "tools": [
+ {"type": "function", "name": "write_file", "parameters": {
+ "type": "object",
+ "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
+ "required": ["path", "content"]}},
+ {"type": "function", "name": "edit_file", "parameters": {
+ "type": "object",
+ "properties": {"path": {"type": "string"}, "edits": {"type": "string"}},
+ "required": ["path", "edits"]}},
+ {"type": "function", "name": "list_allowed_directories", "parameters": {
+ "type": "object", "properties": {}}},
+ ],
+ }],
+}
+
+
+def events(text, tools, thinking=False):
+ parser = OutputParser(thinking=thinking, tools=tools, stream_tools=True)
+ evs = parser.feed(text)
+ evs += parser.finish("stop")
+ return evs
+
+
+def text_of(evs):
+ return "".join(e.text or "" for e in evs if e.kind in ("content", "reasoning"))
+
+
+def response_items(text, tools, names, req=REQ):
+ asm = Assembler(req, "qwen", 10, names, encrypted=False)
+ out = []
+ parser_events = events(text, tools)
+ for ev in parser_events:
+ out += asm.feed(ev)
+ out += asm.finish({"finish": "stop", "completion_tokens": 1, "prompt_tokens": 10})
+ items = [ev["item"] for ev in out if ev.get("type") == "response.output_item.done"]
+ return items, parser_events
+
+
+class DriftedMcpNames(unittest.TestCase):
+ def setUp(self):
+ self.tools, self.names, _skipped = request_tools(REQ)
+
+ def _call(self, text, tools=None, names=None):
+ items, evs = response_items(text, tools or self.tools, names or self.names)
+ calls = [i for i in items if i["type"] == "function_call"]
+ return calls, evs
+
+ def test_equals_write_is_the_namespace_tool(self):
+ raw = (
+ "<tool_call>\n<function=mcp__filesystem=write_file>\n<parameter=path>\n/tmp/x.py\n</parameter>\n"
+ "<parameter=content>\nprint(\"not used\")\n</parameter>\n</function>\n</tool_call>"
+ )
+ calls, evs = self._call(raw)
+ self.assertEqual(text_of(evs).strip(), "")
+ self.assertEqual(len(calls), 1)
+ self.assertEqual((calls[0]["namespace"], calls[0]["name"]), ("mcp__filesystem", "write_file"))
+ args = json.loads(calls[0]["arguments"])
+ self.assertEqual(args["path"], "/tmp/x.py")
+ self.assertIn('print("not used")', args["content"])
+
+ def test_single_underscore_edit_keeps_a_string_argument(self):
+ raw = (
+ "<tool_call>\n<function=mcp__filesystem_edit_file>\n<parameter=path>\n/tmp/a.txt\n</parameter>\n"
+ "<parameter=edits>\nsay \"hi\"\n</parameter>\n</function>\n</tool_call>"
+ )
+ calls, evs = self._call(raw)
+ self.assertEqual(text_of(evs).strip(), "")
+ self.assertEqual((calls[0]["namespace"], calls[0]["name"]), ("mcp__filesystem", "edit_file"))
+ args = json.loads(calls[0]["arguments"])
+ self.assertEqual(args["path"], "/tmp/a.txt")
+ self.assertIsInstance(args["edits"], str)
+ self.assertIn('"hi"', args["edits"])
+
+ def test_bare_write_file_is_the_one_namespace_tool(self):
+ raw = (
+ "<tool_call>\n<function=write_file>\n<parameter=path>\n/tmp/patch-tencut.py\n</parameter>\n"
+ "<parameter=content>\nprint(\"ten\")\n</parameter>\n</function>\n</tool_call>"
+ )
+ calls, evs = self._call(raw)
+ self.assertEqual(text_of(evs).strip(), "")
+ self.assertEqual((calls[0]["namespace"], calls[0]["name"]), ("mcp__filesystem", "write_file"))
+ args = json.loads(calls[0]["arguments"])
+ self.assertEqual(args["path"], "/tmp/patch-tencut.py")
+ self.assertEqual(args["content"], 'print("ten")')
+
+ def test_bare_list_allowed_directories_is_a_call(self):
+ raw = "<tool_call>\n<function=list_allowed_directories>\n</function>\n</tool_call>"
+ calls, evs = self._call(raw)
+ self.assertEqual(text_of(evs).strip(), "")
+ self.assertEqual((calls[0]["namespace"], calls[0]["name"]),
+ ("mcp__filesystem", "list_allowed_directories"))
+ self.assertEqual(json.loads(calls[0]["arguments"]), {})
+
+ def test_double_underscore_still_maps(self):
+ raw = (
+ "<tool_call>\n<function=mcp__filesystem__write_file>\n<parameter=path>\n/tmp/z\n</parameter>\n"
+ "<parameter=content>\nok\n</parameter>\n</function>\n</tool_call>"
+ )
+ calls, _evs = self._call(raw)
+ self.assertEqual((calls[0]["namespace"], calls[0]["name"]), ("mcp__filesystem", "write_file"))
+ self.assertEqual(json.loads(calls[0]["arguments"])["content"], "ok")
+
+ def test_equals_inside_thinking_is_still_a_call(self):
+ raw = (
+ "<tool_call>\n<function=mcp__filesystem=write_file>\n<parameter=path>\n/tmp/x.py\n</parameter>\n"
+ "<parameter=content>\nok\n</parameter>\n</function>\n</tool_call>"
+ )
+ evs = events(raw + "</think>\n", self.tools, thinking=True)
+ found = [e for e in evs if e.kind == "tool_call"]
+ self.assertEqual(len(found), 1)
+ self.assertEqual(found[0].call.arguments["path"], "/tmp/x.py")
+
+ def test_an_unknown_name_stays_text(self):
+ raw = "<tool_call>\n<function=mcp__filesystem=not_a_tool>\n</function>\n</tool_call>"
+ calls, evs = self._call(raw)
+ self.assertEqual(calls, [])
+ self.assertIn("not_a_tool", text_of(evs))
+
+ def test_two_namespaces_sharing_a_member_stay_text(self):
+ req = {"tools": [
+ {"type": "namespace", "name": "mcp__filesystem", "tools": [
+ {"type": "function", "name": "write_file", "parameters": {
+ "type": "object", "properties": {"path": {"type": "string"}}}}]},
+ {"type": "namespace", "name": "mcp__other", "tools": [
+ {"type": "function", "name": "write_file", "parameters": {
+ "type": "object", "properties": {"path": {"type": "string"}}}}]},
+ ]}
+ tools, names, _ = request_tools(req)
+ raw = "<tool_call>\n<function=write_file>\n<parameter=path>\n/tmp/x\n</parameter>\n</function>\n</tool_call>"
+ calls, evs = self._call(raw, tools, names)
+ self.assertEqual(calls, [])
+ self.assertIn("write_file", text_of(evs))
+
+ def test_a_flat_tool_with_the_member_name_wins(self):
+ req = {"tools": [
+ {"type": "function", "name": "write_file", "parameters": {
+ "type": "object", "properties": {"path": {"type": "string"}}}},
+ {"type": "namespace", "name": "mcp__filesystem", "tools": [
+ {"type": "function", "name": "write_file", "parameters": {
+ "type": "object", "properties": {"path": {"type": "string"},
+ "content": {"type": "string"}}}}]},
+ ]}
+ tools, names, _ = request_tools(req)
+ self.assertEqual(names["write_file"], (None, "write_file", "function"))
+ raw = "<tool_call>\n<function=write_file>\n<parameter=path>\n/tmp/x\n</parameter>\n</function>\n</tool_call>"
+ calls, evs = self._call(raw, tools, names)
+ self.assertEqual(text_of(evs).strip(), "")
+ self.assertEqual(calls[0]["name"], "write_file")
+ self.assertNotIn("namespace", calls[0])
+
+
+ def test_a_flat_tool_named_like_the_underscore_alias_wins(self):
+ req = {"tools": [
+ {"type": "function", "name": "mcp__filesystem_write_file", "parameters": {
+ "type": "object", "properties": {"path": {"type": "string"}}}},
+ {"type": "namespace", "name": "mcp__filesystem", "tools": [
+ {"type": "function", "name": "write_file", "parameters": {
+ "type": "object", "properties": {"path": {"type": "string"},
+ "content": {"type": "string"}}}}]},
+ ]}
+ tools, names, _ = request_tools(req)
+ raw = ("<tool_call>\n<function=mcp__filesystem_write_file>\n<parameter=path>\n/tmp/x\n</parameter>\n</function>"
+ "\n</tool_call>")
+ calls, evs = self._call(raw, tools, names)
+ self.assertEqual(text_of(evs).strip(), "")
+ self.assertEqual(calls[0]["name"], "mcp__filesystem_write_file")
+ self.assertNotIn("namespace", calls[0])
+
+
+if __name__ == "__main__":
+ unittest.main()