diff --git a/python/sglang/srt/entrypoints/openai/protocol.py b/python/sglang/srt/entrypoints/openai/protocol.py index 110a0528bc..1734c22b99 100644 --- a/python/sglang/srt/entrypoints/openai/protocol.py +++ b/python/sglang/srt/entrypoints/openai/protocol.py @@ -52,6 +52,9 @@ from openai.types.responses.response import ToolChoice from openai.types.responses.response_format_text_json_schema_config import ( ResponseFormatTextJSONSchemaConfig, ) +from openai.types.responses.response_function_tool_call_param import ( + ResponseFunctionToolCallParam, +) from openai.types.shared.response_format_json_object import ResponseFormatJSONObject from pydantic import ( AfterValidator, @@ -903,6 +906,10 @@ class ChatCompletionRequest(PDRoutingFields): top_p: Optional[float] = None user: Optional[str] = None tools: Optional[List[Tool]] = Field(default=None, examples=[None]) + # Set by /v1/responses when the request has namespace tools: the chat template + # renders these, while ``tools`` (flattened to ``.``) still + # drives tool-call parsing. + _template_tools: Optional[List[Dict[str, Any]]] = PrivateAttr(default=None) tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]] = Field( default="auto", examples=["none"] ) # noqa @@ -1807,6 +1814,7 @@ class ResponseTool(BaseModel): strict: bool = False # Inner schemas for ``namespace`` tools. tools: Optional[List[Dict[str, Any]]] = None + defer_loading: Optional[bool] = None # Input format of a ``custom`` tool: {"type": "text"} or # {"type": "grammar", "syntax": ..., "definition": ...}. format: Optional[Dict[str, Any]] = None @@ -1822,12 +1830,18 @@ class ResponseInputMessageParam(EasyInputMessageParam, total=False): phase: Optional[Literal["commentary", "final_answer"]] +class ResponseFunctionCallInputParam(ResponseFunctionToolCallParam, total=False): + # Set when the call targets a member of a ``namespace`` tool. + namespace: str + + class ResponseOutputMessage(OpenAIResponseOutputMessage): phase: Optional[Literal["commentary", "final_answer"]] = None ResponseInputOutputItem: TypeAlias = Union[ ResponseInputMessageParam, + ResponseFunctionCallInputParam, ResponseOutputMessage, ResponseInputItemParam, "ResponseReasoningItem", @@ -2351,6 +2365,7 @@ class ResponseReasoningTextContent(BaseModel): ResponseInputOutputItem: TypeAlias = Union[ ResponseInputMessageParam, + ResponseFunctionCallInputParam, ResponseOutputMessage, ResponseInputItemParam, "ResponseReasoningItem", diff --git a/python/sglang/srt/entrypoints/openai/responses_adapters.py b/python/sglang/srt/entrypoints/openai/responses_adapters.py index 0d82012bbe..203b154c1e 100644 --- a/python/sglang/srt/entrypoints/openai/responses_adapters.py +++ b/python/sglang/srt/entrypoints/openai/responses_adapters.py @@ -17,7 +17,7 @@ from __future__ import annotations import base64 import json import zlib -from typing import Any, Dict, Optional, Set, Tuple +from typing import Any, Dict, Iterator, Optional, Set, Tuple CUSTOM_TOOL_INPUT_KEY = "input" @@ -72,6 +72,27 @@ def custom_tool_names(tools: Any) -> Set[str]: return {tool.name for tool in tools or [] if tool.type == "custom" and tool.name} +def namespace_functions(tool: Any) -> Iterator[Dict[str, Any]]: + """Unwrap the flat and OpenAI-wrapped members accepted by Muse's template.""" + for member in tool.tools or []: + if member.get("type", "function") != "function": + continue + function = member.get("function", member) + if isinstance(function, dict) and function.get("name"): + yield function + + +def namespace_function_names(tools: Any) -> Dict[str, Tuple[str, str]]: + """Map each namespace member's call name ``.`` to + ``(namespace, function)``.""" + return { + f"{tool.name}.{member['name']}": (tool.name, member["name"]) + for tool in tools or [] + if tool.type == "namespace" and tool.name + for member in namespace_functions(tool) + } + + def encode_custom_tool_input(payload: str) -> str: return json.dumps({CUSTOM_TOOL_INPUT_KEY: payload}, ensure_ascii=False) diff --git a/python/sglang/srt/entrypoints/openai/serving_chat.py b/python/sglang/srt/entrypoints/openai/serving_chat.py index 12378585e7..32e30503db 100644 --- a/python/sglang/srt/entrypoints/openai/serving_chat.py +++ b/python/sglang/srt/entrypoints/openai/serving_chat.py @@ -1454,6 +1454,8 @@ class OpenAIServingChat(OpenAIServingBase): ] or None elif request.tools: tools = [item.model_dump() for item in request.tools] + if self.tool_call_parser == "muse" and request._template_tools: + tools = request._template_tools if self.tool_call_parser and not glm_constraint: parser = FunctionCallParser( effective_tools, diff --git a/python/sglang/srt/entrypoints/openai/serving_responses.py b/python/sglang/srt/entrypoints/openai/serving_responses.py index b85d4da840..0021fc596f 100644 --- a/python/sglang/srt/entrypoints/openai/serving_responses.py +++ b/python/sglang/srt/entrypoints/openai/serving_responses.py @@ -83,6 +83,8 @@ from sglang.srt.entrypoints.openai.responses_adapters import ( encode_custom_tool_input, encode_reasoning_state, label_developer_content, + namespace_function_names, + namespace_functions, ) from sglang.srt.entrypoints.openai.serving_chat import ( OpenAIServingChat, @@ -704,6 +706,7 @@ class OpenAIServingResponses(OpenAIServingChat): reasoning_effort=(request.reasoning.effort if request.reasoning else None), chat_template_kwargs=request.chat_template_kwargs, ) + chat_request._template_tools = self._response_tools_to_template_tools(request) media_error = self._validate_media_content(chat_request) if media_error: @@ -946,10 +949,14 @@ class OpenAIServingResponses(OpenAIServingChat): @staticmethod def _make_tool_call_item( - name: str, arguments: str, custom_names: set[str] + name: str, + arguments: str, + custom_names: set[str], + namespace_names: Optional[dict[str, tuple[str, str]]] = None, ) -> Union[ResponseFunctionToolCall, ResponseCustomToolCall]: """A call against a ``custom`` tool reports its freeform payload rather - than the JSON arguments of the shim function tool.""" + than the JSON arguments of the shim function tool. A call against a + namespace member reports ``namespace`` and the bare function ``name``.""" call_id = f"call_{random_uuid()[:24]}" if name in custom_names: return ResponseCustomToolCall( @@ -959,6 +966,7 @@ class OpenAIServingResponses(OpenAIServingChat): name=name, input=decode_custom_tool_input(arguments), ) + namespace, name = (namespace_names or {}).get(name, (None, name)) return ResponseFunctionToolCall( arguments=arguments, call_id=call_id, @@ -966,6 +974,7 @@ class OpenAIServingResponses(OpenAIServingChat): name=name, id=f"fc_{random_uuid()[:8]}", status="completed", + **({"namespace": namespace} if namespace else {}), ) @staticmethod @@ -1055,6 +1064,11 @@ class OpenAIServingResponses(OpenAIServingChat): ): chat_tools = self._response_tools_to_chat_tools(request) custom_names = custom_tool_names(request.tools) + namespace_names = ( + namespace_function_names(request.tools) + if self.tool_call_parser == "muse" + else {} + ) encoding_output = self._encoding_output() if encoding_output is not None: required_json = self._uses_required_tool_json(request, chat_tools) @@ -1069,11 +1083,13 @@ class OpenAIServingResponses(OpenAIServingChat): ) if required_json and content: content, tool_call_items = self._parse_required_tool_json( - content, custom_names + content, custom_names, namespace_names ) else: tool_call_items = [ - self._make_tool_call_item(call.name, call.parameters, custom_names) + self._make_tool_call_item( + call.name, call.parameters, custom_names, namespace_names + ) for call in calls ] else: @@ -1082,6 +1098,7 @@ class OpenAIServingResponses(OpenAIServingChat): final_output, chat_tools, custom_names, + namespace_names=namespace_names, require_reasoning=require_reasoning, ) @@ -1122,6 +1139,7 @@ class OpenAIServingResponses(OpenAIServingChat): chat_tools: list[Tool], custom_names: set[str], *, + namespace_names: dict[str, tuple[str, str]], require_reasoning: bool, ) -> tuple[ Optional[str], @@ -1179,6 +1197,7 @@ class OpenAIServingResponses(OpenAIServingChat): call_info.name, call_info.parameters or "", custom_names, + namespace_names, ) ) parsed_via_native = bool(call_info_list) @@ -1192,12 +1211,17 @@ class OpenAIServingResponses(OpenAIServingChat): and not parsed_via_native and not detector_owns_format ): - content, json_items = self._parse_required_tool_json(content, custom_names) + content, json_items = self._parse_required_tool_json( + content, custom_names, namespace_names + ) tool_call_items.extend(json_items) return reasoning_content, content, tool_call_items def _parse_required_tool_json( - self, content: str, custom_names: set[str] + self, + content: str, + custom_names: set[str], + namespace_names: Optional[dict[str, tuple[str, str]]] = None, ) -> tuple[str, list[Union[ResponseFunctionToolCall, ResponseCustomToolCall]]]: tool_call_items = [] try: @@ -1212,7 +1236,9 @@ class OpenAIServingResponses(OpenAIServingChat): tool.get("parameters", {}), ensure_ascii=False ) tool_call_items.append( - self._make_tool_call_item(tool["name"], arguments, custom_names) + self._make_tool_call_item( + tool["name"], arguments, custom_names, namespace_names + ) ) content = "" except Exception as e: @@ -1298,12 +1324,29 @@ class OpenAIServingResponses(OpenAIServingChat): return tool_choice return {"type": "function", "function": {"name": tool_choice["name"]}} - @staticmethod - def _response_tools_to_chat_tools(request: ResponsesRequest) -> list[Tool]: + def _response_tools_to_chat_tools(self, request: ResponsesRequest) -> list[Tool]: # ``function`` and ``custom`` tools flow to chat; built-ins go through # harmony. A custom tool is shimmed into a single-string function tool. chat_tools = [] + is_muse = self.tool_call_parser == "muse" for tool in request.tools: + if is_muse and tool.type == "namespace" and tool.name: + # Members are called as ``.``; register those + # names so the tool-call parser accepts the calls. + for member in namespace_functions(tool): + chat_tools.append( + Tool( + type="function", + function=Function( + name=f"{tool.name}.{member['name']}", + description=member.get("description"), + parameters=member.get("parameters"), + strict=bool(member.get("strict", False)), + defer_loading=member.get("defer_loading"), + ), + ) + ) + continue if tool.type == "function": description, parameters = tool.description, tool.parameters elif tool.type == "custom" and tool.name: @@ -1319,11 +1362,51 @@ class OpenAIServingResponses(OpenAIServingChat): description=description, parameters=parameters, strict=tool.strict, + defer_loading=tool.defer_loading if is_muse else None, ), ) ) return chat_tools + def _response_tools_to_template_tools( + self, + request: ResponsesRequest, + ) -> Optional[list[dict]]: + """Tools for Muse's chat template when the request has namespace tools: + namespaces stay nested, so the template can render namespace metadata and + namespace-level ``defer_loading``. None keeps the flattened tool list.""" + if self.tool_call_parser != "muse" or not any( + tool.type == "namespace" for tool in request.tools + ): + return None + template_tools: list[dict] = [] + for tool in request.tools: + if tool.type == "namespace" and tool.name: + namespace = { + "type": "namespace", + "name": tool.name, + "description": tool.description or "", + "tools": [dict(member) for member in namespace_functions(tool)], + } + if tool.defer_loading is not None: + namespace["defer_loading"] = tool.defer_loading + template_tools.append(namespace) + elif tool.type in ("function", "custom") and tool.name: + function = { + "name": tool.name, + "description": tool.description, + "parameters": tool.parameters, + } + if tool.type == "custom": + function["description"] = custom_tool_description( + tool.description, tool.format + ) + function["parameters"] = custom_tool_parameters() + if tool.defer_loading is not None: + function["defer_loading"] = tool.defer_loading + template_tools.append({"type": "function", "function": function}) + return template_tools + @staticmethod def _normalize_response_content_part_for_chat(content_part: Any) -> Any: # Default detail=\"auto\" and lift flat min/max_dynamic_patch onto @@ -1390,7 +1473,9 @@ class OpenAIServingResponses(OpenAIServingChat): } @classmethod - def _normalize_response_message_for_chat(cls, message: Any) -> Any: + def _normalize_response_message_for_chat( + cls, message: Any, *, tool_call_parser: Optional[str] = None + ) -> Any: """Convert one Responses-API input item to a chat-completions message.""" if hasattr(message, "model_dump"): message = message.model_dump(exclude_none=True) @@ -1424,7 +1509,10 @@ class OpenAIServingResponses(OpenAIServingChat): raw = orjson.dumps(raw).decode("utf-8") else: raw = "{}" - return cls._chat_tool_call_message(message, message.get("name"), raw) + name = message.get("name") + if tool_call_parser == "muse" and message.get("namespace"): + name = f"{message['namespace']}.{name}" + return cls._chat_tool_call_message(message, name, raw) if msg_type == "custom_tool_call": # Replay through the same single-string shim the tool was offered as. return cls._chat_tool_call_message( @@ -1572,7 +1660,9 @@ class OpenAIServingResponses(OpenAIServingChat): ) for input_item in self._response_input_history(request): - normalized = self._normalize_response_message_for_chat(input_item) + normalized = self._normalize_response_message_for_chat( + input_item, tool_call_parser=self.tool_call_parser + ) if normalized is not None: messages.append(normalized) @@ -2124,6 +2214,11 @@ class OpenAIServingResponses(OpenAIServingChat): chat_tools = self._response_tools_to_chat_tools(request) custom_names = custom_tool_names(request.tools) + namespace_names = ( + namespace_function_names(request.tools) + if self.tool_call_parser == "muse" + else {} + ) tool_choice = request.effective_tool_choice() required_json = self._uses_required_tool_json(request, chat_tools) encoding_output = self._encoding_output() @@ -2345,6 +2440,9 @@ class OpenAIServingResponses(OpenAIServingChat): message_state["open"] = False return events + def _namespace_field(state: dict) -> dict: + return {"namespace": state["namespace"]} if state["namespace"] else {} + def _close_tool_call_state(tool_index: int): state = tool_call_states.get(tool_index) if state is None or state.get("done"): @@ -2402,6 +2500,7 @@ class OpenAIServingResponses(OpenAIServingChat): type="function_call", id=state["item_id"], status=item_status, + **_namespace_field(state), ) events.append( _send_event( @@ -2614,6 +2713,7 @@ class OpenAIServingResponses(OpenAIServingChat): current_output_index += 1 name = call.name or "" is_custom = name in custom_names + namespace, name = namespace_names.get(name, (None, name)) state = { "item_id": ( f"ctc_{random_uuid()[:8]}" @@ -2623,6 +2723,7 @@ class OpenAIServingResponses(OpenAIServingChat): "call_id": f"call_{random_uuid()[:24]}", "output_index": current_output_index, "name": name, + "namespace": namespace, "arguments": "", "custom": is_custom, "payload": "", @@ -2648,6 +2749,7 @@ class OpenAIServingResponses(OpenAIServingChat): type="function_call", id=state["item_id"], status="in_progress", + **_namespace_field(state), ) yield _send_event( openai_responses_types.ResponseOutputItemAddedEvent( diff --git a/test/registered/unit/entrypoints/openai/test_responses_custom_tools.py b/test/registered/unit/entrypoints/openai/test_responses_custom_tools.py index da8a3116de..8a3ca526ba 100644 --- a/test/registered/unit/entrypoints/openai/test_responses_custom_tools.py +++ b/test/registered/unit/entrypoints/openai/test_responses_custom_tools.py @@ -71,7 +71,7 @@ class CustomToolAdapterTestCase(CustomTestCase): class CustomToolShimTestCase(CustomTestCase): def test_custom_tool_becomes_a_single_string_function_tool(self): request = _custom_request() - (tool,) = OpenAIServingResponses._response_tools_to_chat_tools(request) + (tool,) = make_serving()._response_tools_to_chat_tools(request) self.assertEqual(tool.function.name, "emit_command") self.assertEqual(list(tool.function.parameters["properties"]), ["input"]) self.assertEqual(tool.function.parameters["required"], ["input"]) @@ -79,9 +79,7 @@ class CustomToolShimTestCase(CustomTestCase): nameless = ResponsesRequest( model="x", input="hi", tools=[{"type": "custom"}], store=False ) - self.assertEqual( - OpenAIServingResponses._response_tools_to_chat_tools(nameless), [] - ) + self.assertEqual(make_serving()._response_tools_to_chat_tools(nameless), []) def test_grammar_format_is_described_to_the_model(self): request = _custom_request( @@ -96,7 +94,7 @@ class CustomToolShimTestCase(CustomTestCase): } ] ) - (tool,) = OpenAIServingResponses._response_tools_to_chat_tools(request) + (tool,) = make_serving()._response_tools_to_chat_tools(request) self.assertIn("lark", tool.function.description) self.assertIn('start: "pwd"', tool.function.description) diff --git a/test/registered/unit/entrypoints/openai/test_responses_namespace_tools.py b/test/registered/unit/entrypoints/openai/test_responses_namespace_tools.py new file mode 100644 index 0000000000..66b238a035 --- /dev/null +++ b/test/registered/unit/entrypoints/openai/test_responses_namespace_tools.py @@ -0,0 +1,359 @@ +import asyncio +import json +import unittest + +from transformers.utils.chat_template_utils import _compile_jinja_template +from utils import ( + StreamFixture, + engine_chunk, + event_payloads, + event_types, + find_completed_event, + make_serving, +) + +from sglang.srt.entrypoints.openai.protocol import ResponsesRequest +from sglang.test.ci.ci_register import register_cpu_ci +from sglang.test.test_utils import CustomTestCase + +register_cpu_ci(est_time=5, suite="base-a-test-cpu") + +QUERY = { + "type": "object", + "properties": {"query": {"type": "string"}}, + "required": ["query"], +} +BROWSER = { + "type": "namespace", + "name": "browser", + "description": "Browse the web", + "defer_loading": True, + "tools": [ + { + "type": "function", + "name": "search", + "description": "Search the web", + "parameters": QUERY, + "defer_loading": False, + } + ], +} +LOOKUP = { + "type": "function", + "name": "lookup", + "description": "Look up a record.", + "parameters": QUERY, + "defer_loading": True, +} + + +def _request(**kwargs) -> ResponsesRequest: + payload = { + "model": "x", + "input": "search", + "tools": [BROWSER, LOOKUP], + "store": False, + } + payload.update(kwargs) + return ResponsesRequest(**payload) + + +def _muse_serving(): + serving = make_serving() + serving.tool_call_parser = "muse" + return serving + + +class NamespaceToolChatToolsTestCase(CustomTestCase): + def test_function_tool_keeps_defer_loading(self): + """``defer_loading`` on a Responses function tool used to be dropped while + parsing the request, so the chat template rendered a deferred tool in full.""" + tools = _muse_serving()._response_tools_to_chat_tools(_request()) + by_name = {tool.function.name: tool.function for tool in tools} + self.assertTrue(by_name["lookup"].defer_loading) + + def test_namespace_members_are_registered_under_qualified_names(self): + """The tool-call parser only accepts registered names, and the model calls + namespace members as ``.``.""" + tools = _muse_serving()._response_tools_to_chat_tools(_request()) + self.assertEqual( + [tool.function.name for tool in tools], ["browser.search", "lookup"] + ) + + +class NamespaceToolTemplateTestCase(CustomTestCase): + def _template_tools(self, request, tool_call_parser="muse"): + serving = make_serving() + serving.tool_call_parser = tool_call_parser + serving.template_manager.chat_template_name = None + serving.template_manager.jinja_template_content_format = "string" + serving._prompt_text_round_trip_is_lossy = False + tokenizer = serving.tokenizer_manager.tokenizer + template = _compile_jinja_template("{{ tools | tojson }}") + tokenizer.apply_chat_template.side_effect = lambda messages, **kwargs: ( + template.render(messages=messages, **kwargs) + ) + tokenizer.encode.side_effect = lambda text, **kwargs: list(text.encode("utf-8")) + _, _, _, processed = asyncio.run( + serving._make_request(request, None, tokenizer) + ) + return json.loads(bytes(processed.prompt_ids).decode("utf-8")) + + def test_namespace_reaches_the_template_nested(self): + """Muse distinguishes inherited, explicitly eager and deferred members; + flattening namespaces or filling absent flags changes its prompt.""" + members = [ + {"name": "inherited", "parameters": QUERY}, + {"name": "eager", "parameters": QUERY, "defer_loading": False}, + {"name": "deferred", "parameters": QUERY, "defer_loading": True}, + ] + for wrapped in (False, True): + with self.subTest(wrapped=wrapped): + supplied = ( + [{"type": "function", "function": member} for member in members] + if wrapped + else members + ) + tools = self._template_tools( + _request(tools=[{**BROWSER, "tools": supplied}, LOOKUP]) + ) + self.assertEqual(tools[0]["type"], "namespace") + self.assertEqual(tools[0]["name"], "browser") + self.assertEqual(tools[0]["description"], "Browse the web") + self.assertTrue(tools[0]["defer_loading"]) + functions = [m.get("function", m) for m in tools[0]["tools"]] + self.assertEqual( + [m["name"] for m in functions], ["inherited", "eager", "deferred"] + ) + self.assertNotIn("defer_loading", functions[0]) + self.assertFalse(functions[1]["defer_loading"]) + self.assertTrue(functions[2]["defer_loading"]) + self.assertEqual(tools[1]["function"]["name"], "lookup") + self.assertTrue(tools[1]["function"]["defer_loading"]) + + def test_requests_without_namespaces_keep_the_flattened_tools(self): + (tool,) = self._template_tools(_request(tools=[LOOKUP])) + self.assertEqual(tool["function"]["name"], "lookup") + self.assertTrue(tool["function"]["defer_loading"]) + + def test_non_muse_keeps_existing_function_and_custom_tool_schemas(self): + """Muse-only metadata must not change another model's rendered tools.""" + custom = { + "type": "custom", + "name": "execute", + "description": "Execute a command.", + "format": { + "type": "grammar", + "syntax": "lark", + "definition": 'start: "pwd"', + }, + } + function = {k: v for k, v in LOOKUP.items() if k != "defer_loading"} + for parser in (None, "qwen25", "llama3"): + with self.subTest(parser=parser): + expected = self._template_tools( + _request(tools=[function, custom]), parser + ) + self.assertEqual( + [tool["function"]["name"] for tool in expected], + ["lookup", "execute"], + ) + self.assertEqual( + expected[1]["function"]["parameters"]["required"], ["input"] + ) + for namespaces in ([], [BROWSER]): + with self.subTest(namespaces=bool(namespaces)): + actual = self._template_tools( + _request( + tools=[ + *namespaces, + LOOKUP, + {**custom, "defer_loading": True}, + ] + ), + parser, + ) + self.assertEqual(actual, expected) + + def test_namespace_does_not_hide_custom_tool_schema(self): + """Adding a namespace must not remove a custom tool from the prompt.""" + for tool_format in ( + {"type": "text"}, + {"type": "grammar", "syntax": "lark", "definition": 'start: "pwd"'}, + ): + with self.subTest(tool_format=tool_format): + custom = { + "type": "custom", + "name": "execute", + "description": "Execute a command.", + "format": tool_format, + "defer_loading": True, + } + tools = self._template_tools(_request(tools=[BROWSER, custom])) + self.assertEqual(len(tools), 2) + function = tools[1]["function"] + self.assertEqual(function["name"], "execute") + self.assertEqual(function["parameters"]["required"], ["input"]) + self.assertEqual( + function["parameters"]["properties"]["input"]["type"], "string" + ) + self.assertTrue(function["defer_loading"]) + self.assertIn("Execute a command.", function["description"]) + if tool_format["type"] == "grammar": + self.assertIn('start: "pwd"', function["description"]) + + +class NamespaceToolCallOutputTestCase(CustomTestCase): + RAW = ( + '[{"name": "browser.search", "parameters": {"query": "news"}},' + ' {"name": "lookup", "parameters": {"query": "C123"}}]' + ) + QWEN_RAW = ( + '\n{"name": "browser.search", "arguments": {"query": "news"}}\n' + '\n\n{"name": "lookup", "arguments": {"query": "C123"}}\n' + ) + + def _serving(self, parser=None): + serving = make_serving() + serving.reasoning_parser = None + serving.tool_call_parser = parser + return serving + + def _assert_unsplit(self, items): + search, lookup = items + self.assertEqual(search["type"], "function_call") + self.assertEqual(search["name"], "browser.search") + self.assertNotIn("namespace", search) + self.assertEqual(json.loads(search["arguments"]), {"query": "news"}) + self.assertEqual(lookup["name"], "lookup") + self.assertNotIn("namespace", lookup) + + def test_non_muse_full_response_keeps_dotted_function_names(self): + """A namespace must not rename another model's ordinary function calls.""" + for parser in (None, "qwen25"): + with self.subTest(parser=parser): + items = self._serving(parser)._make_response_output_items( + _request( + tools=[BROWSER, {**LOOKUP, "name": "browser.search"}, LOOKUP], + tool_choice="required", + ), + self.RAW if parser is None else self.QWEN_RAW, + tokenizer=None, + require_reasoning=False, + ) + self._assert_unsplit( + [item.model_dump(exclude_none=True) for item in items] + ) + + def test_non_muse_stream_keeps_dotted_function_names(self): + request = _request( + tools=[BROWSER, {**LOOKUP, "name": "browser.search"}, LOOKUP], + tool_choice="required", + stream=True, + ) + for parser in (None, "qwen25"): + with self.subTest(parser=parser): + raw = ( + '[{"name": "browser.search", "parameters": {"query": "news"}}]' + if parser is None + else self.QWEN_RAW.split("\n")[0] + ) + events = StreamFixture(self._serving(parser), request).run( + [engine_chunk(raw[:30]), engine_chunk(raw, 2, finish=True)] + ) + pairs = list(zip(event_types(events), event_payloads(events))) + items = [ + p["item"] for t, p in pairs if t.startswith("response.output_item.") + ] + items += find_completed_event(events)["response"]["output"] + self.assertEqual(len(items), 3) + for item in items: + self.assertEqual(item["name"], "browser.search") + self.assertNotIn("namespace", item) + + def test_muse_calls_accept_flat_and_wrapped_namespace_members(self): + """Both member shapes accepted by Muse's template must parse and split. + + Template contract: meta-models/Muse-Spark-Open-816B-A42B-NVFP4, + revision 4239e4db19376904f2e82c167e78f70abb5455fe. + """ + raw = ( + " to=browser.search<|message|>" + '' + 'news' + "<|eot|>" + ) + function = {"name": "search", "parameters": QUERY, "defer_loading": True} + for member in (function, {"type": "function", "function": function}): + with self.subTest(member=member): + request = _request(tools=[{**BROWSER, "tools": [member]}]) + serving = self._serving("muse") + tools = serving._response_tools_to_chat_tools(request) + self.assertEqual( + [tool.function.name for tool in tools], ["browser.search"] + ) + self.assertTrue(tools[0].function.defer_loading) + items = serving._make_response_output_items( + request, raw, tokenizer=None, require_reasoning=False + ) + self.assertEqual(len(items), 1) + full = items[0].model_dump(exclude_none=True) + events = StreamFixture(serving, request).run( + [engine_chunk(raw[:70]), engine_chunk(raw, 2, finish=True)] + ) + pairs = list(zip(event_types(events), event_payloads(events))) + streamed = [ + p["item"] for t, p in pairs if t.startswith("response.output_item.") + ] + streamed += find_completed_event(events)["response"]["output"] + self.assertEqual(len(streamed), 3) + for item in (full, *streamed): + self.assertEqual(item["type"], "function_call") + self.assertEqual( + (item["namespace"], item["name"]), ("browser", "search") + ) + if item["status"] == "completed": + self.assertEqual( + json.loads(item["arguments"]), {"query": "news"} + ) + + +class NamespaceToolCallReplayTestCase(CustomTestCase): + def test_replayed_call_is_rejoined_only_for_muse(self): + """The template and the tool-call parser know the call as + ``.``; a replayed item carries the two separately.""" + request = _request( + input=[ + {"role": "user", "content": "search"}, + { + "type": "function_call", + "call_id": "call_1", + "namespace": "browser", + "name": "search", + "arguments": '{"query": "news"}', + }, + { + "type": "function_call", + "call_id": "call_2", + "name": "lookup", + "arguments": '{"query": "C123"}', + }, + ] + ) + for parser in ("muse", None, "qwen25"): + with self.subTest(parser=parser): + serving = make_serving() + serving.tool_call_parser = parser + messages = serving._construct_input_messages(request) + self.assertEqual( + [ + call["function"]["name"] + for message in messages + for call in message.get("tool_calls", []) + ], + ["browser.search" if parser == "muse" else "search", "lookup"], + ) + + +if __name__ == "__main__": + unittest.main()