Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
Studio: stop hiding MCP tools that have a dot or a long name (#11051)
Nilay8453ef4a38fb
diff --git a/studio/backend/core/inference/studio_tool_loop.py b/studio/backend/core/inference/studio_tool_loop.pyindex ec493b8b115..80d99859061 100644--- a/studio/backend/core/inference/studio_tool_loop.py+++ b/studio/backend/core/inference/studio_tool_loop.py@@ -1007,12 +1007,13 @@ def _split_turn_end(def _unrun_provenance(tool_name: str, round_id: int) -> dict[str, Any]:- """Provenance for a hand-built unrun card; carries the MCP display name so a budget-exhausted or- truncated MCP call never shows the internal server id."""+ """Provenance for a hand-built unrun card; carries the MCP display names so a budget-exhausted+ or truncated MCP call never shows the internal server id or an alias."""provenance: dict[str, Any] = {"source": "local", "round_id": round_id}mcp = mcp_display_parts(tool_name)if mcp:provenance["mcp_server"] = mcp[0]+ provenance["mcp_tool"] = mcp[1]return provenancediff --git a/studio/backend/core/inference/tool_loop_controller.py b/studio/backend/core/inference/tool_loop_controller.pyindex 5796a50e8c1..be7802a2184 100644--- a/studio/backend/core/inference/tool_loop_controller.py+++ b/studio/backend/core/inference/tool_loop_controller.py@@ -724,12 +724,14 @@ def mcp_display_parts(tool_name: str) -> "tuple[str, str] | None":if len(parts) < 3 or not parts[1] or not parts[2]:return Nonetry:+ from core.inference.tools import _mcp_raw_tool_namefrom storage import mcp_servers_db+server = mcp_servers_db.get_server_for_tool(parts[1])+ display = (server or {}).get("display_name")+ return (str(display), _mcp_raw_tool_name(tool_name)) if display else Noneexcept Exception: # noqa: BLE001return None- display = (server or {}).get("display_name")- return (str(display), parts[2]) if display else Nonedef provisional_tool_provenance(tool_name: str) -> dict[str, object]:@@ -739,6 +741,7 @@ def provisional_tool_provenance(tool_name: str) -> dict[str, object]:return tool_event_provenance(provisional = True,mcp_server = mcp[0] if mcp else None,+ mcp_tool = mcp[1] if mcp else None,)@@ -1129,6 +1132,7 @@ class ToolLoopController:forced = forced,provisional = provisional,mcp_server = mcp[0] if mcp else None,+ mcp_tool = mcp[1] if mcp else None,)action: ToolAction = "execute"noop = ""diff --git a/studio/backend/core/inference/tools.py b/studio/backend/core/inference/tools.pyindex 11907464cec..993efc48c1b 100644--- a/studio/backend/core/inference/tools.py+++ b/studio/backend/core/inference/tools.py@@ -2018,6 +2018,9 @@ _AUTO_SENSITIVE_MCP_NOUN_RE = re.compile(# Split a camelCase boundary with an underscore (runCommand -> run_Command) so the term-boundary MCP regexes match# camelCase tool names too._CAMEL_CASE_RE = re.compile(r"(?<=[a-z0-9])(?=[A-Z])")+# The term-boundary regexes above recognise only `_` and `-`, but MCP names may separate terms with anything the+# spec allows (catalog.get-catalog-entity). Fold the rest to `_` so a verb behind a dot is still its own term.+_MCP_TERM_SEPARATOR_RE = re.compile(r"[^A-Za-z0-9_\-]+")# A name that reads (get_release, search_code) names its SUBJECT, not the action, so the impact and runtime-noun# patterns below must not fire on it, or the everyday read tools of every server would prompt._AUTO_READ_MCP_VERB_RE = re.compile(@@ -6588,9 +6591,10 @@ def is_potentially_unsafe_tool_call(name: str, arguments: dict) -> bool:if name == "render_html":return _render_html_reaches_network(arguments)if name.startswith(MCP_TOOL_PREFIX):- tool_name = name.split("__", 2)[-1]+ tool_name = _mcp_raw_tool_name(name)if tool_name in _BLENDER_CLI_SUMMARY_TOOLS:return True+ tool_name = _MCP_TERM_SEPARATOR_RE.sub("_", tool_name)# A mutating verb anywhere (get_or_create_issue, read_and_delete)# overrides a read-only prefix.if _AUTO_UNSAFE_MCP_VERB_RE.search(tool_name):@@ -8689,12 +8693,12 @@ def is_high_risk_tool_call(name: str, arguments: dict) -> bool:# A static canvas is fine; only a networked canvas can egress.return _render_html_reaches_network(arguments)if name.startswith(MCP_TOOL_PREFIX):- tool_name = name.split("__", 2)[-1]+ tool_name = _mcp_raw_tool_name(name)if tool_name in _BLENDER_CLI_SUMMARY_TOOLS:return True- # Split camelCase into `_`-delimited terms so the term-boundary regexes- # below match camelCase names too.- tool_name = _CAMEL_CASE_RE.sub("_", tool_name)+ # Reduce every separator the name uses to `_`, camelCase boundaries included, so the+ # term-boundary regexes below see one vocabulary.+ tool_name = _CAMEL_CASE_RE.sub("_", _MCP_TERM_SEPARATOR_RE.sub("_", tool_name))# An execution tool runs arbitrary commands on the MCP server, outside the terminal sandbox; a credential noun# discloses secrets; a read/write pointed at a sensitive path is a sensitive access. All prompt, while# ordinary create/update/delete MCP calls run.@@ -12253,9 +12257,13 @@ DEEP_RESEARCH_TOOL = {}-# OpenAI's function.name regex; MCP names that violate it would 400 the whole request, so validate up front and skip-# with a warning.-_OPENAI_FN_NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{1,64}$")+# OpenAI's function.name regex; MCP names that violate it would 400 the whole request, so they ship under an alias.+_OPENAI_FN_NAME_MAX = 64+_OPENAI_FN_NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{1,%d}$" % _OPENAI_FN_NAME_MAX)++_MCP_ALIAS_DIGEST_LEN = 8+# The "_" plus digest every alias ends with, which is the room its stem does not get.+_MCP_ALIAS_SUFFIX_LEN = _MCP_ALIAS_DIGEST_LEN + 1def _mcp_tool_model_visible(tool: dict) -> bool:@@ -12276,9 +12284,47 @@ def _mcp_tool_model_visible(tool: dict) -> bool:return True+def _mcp_tool_names(server: dict, mcp_tools: list[dict]) -> dict[str, str]:+ """Composed function name -> raw MCP name, for the tools this server ships to a model.++ Names that already satisfy ``function.name`` are claimed first, so an alias minted for a dotted+ or oversized one can never take a name another tool ships under.+ """+ server_key = "blender" if server.get("builtin_id") == "blender" else server["id"]+ prefix = f"{MCP_TOOL_PREFIX}{server_key}__"+ raw_names = [+ tool["name"] for tool in mcp_tools if tool.get("name") and _mcp_tool_model_visible(tool)+ ]+ names: dict[str, str] = {}+ for raw_name in raw_names:+ if _OPENAI_FN_NAME_RE.fullmatch(prefix + raw_name):+ names.setdefault(prefix + raw_name, raw_name)+ stem_room = max(0, _OPENAI_FN_NAME_MAX - len(prefix) - _MCP_ALIAS_SUFFIX_LEN)+ for raw_name in raw_names:+ if _OPENAI_FN_NAME_RE.fullmatch(prefix + raw_name):+ continue+ encoded = raw_name.encode("utf-8", "surrogatepass")+ digest = hashlib.sha256(encoded).hexdigest()[:_MCP_ALIAS_DIGEST_LEN]+ stem = re.sub(r"[^a-zA-Z0-9_-]", "_", raw_name)[:stem_room]+ alias = f"{prefix}{stem}_{digest}"+ if _OPENAI_FN_NAME_RE.fullmatch(alias):+ names.setdefault(alias, raw_name)+ return names+++# Aliases already shown to a model. Kept apart from the tool cache so an in-flight call still resolves after an edit+# evicts it.+_MCP_TOOL_ALIASES: dict[str, str] = {}+++def _mcp_raw_tool_name(name: str) -> str:+ return _MCP_TOOL_ALIASES.get(name) or name.split("__", 2)[-1]++def _mcp_specs_for_server(server: dict, mcp_tools: list[dict]) -> list[dict]:"""Convert an MCP server's tool list into OpenAI function specs."""display = server.get("display_name") or server["id"]+ names_by_raw = {raw_name: name for name, raw_name in _mcp_tool_names(server, mcp_tools).items()}specs: list[dict] = []seen_names: set[str] = set()for tool in mcp_tools:@@ -12289,30 +12335,34 @@ def _mcp_specs_for_server(server: dict, mcp_tools: list[dict]) -> list[dict]:if not _mcp_tool_model_visible(tool):logger.debug("Skipping app-only MCP tool '%s' on '%s'.", raw_name, display)continue- server_key = "blender" if server.get("builtin_id") == "blender" else server["id"]- name = f"{MCP_TOOL_PREFIX}{server_key}__{raw_name}"- # Bad chars or oversized names would 400 the whole request; skip + warn- # so the rest of the tools still ship.- if not _OPENAI_FN_NAME_RE.fullmatch(name):+ name = names_by_raw.get(raw_name)+ if name is None:logger.warning(- "Skipping MCP tool '%s' on '%s': composed name '%s' is not "- "valid OpenAI function.name (regex ^[a-zA-Z0-9_-]{1,64}$).",+ "Skipping MCP tool '%s' on '%s': no free OpenAI function.name for it.",raw_name,display,- name,)continue- # Duplicate tool names would also 400 OpenAI; drop dupes.+ # Duplicate names would 400 OpenAI; drop dupes.if name in seen_names:logger.warning("Skipping duplicate MCP tool '%s' on '%s'.", raw_name, display)continueseen_names.add(name)+ description = tool.get("description") or ""+ if name.split("__", 2)[2] != raw_name:+ _MCP_TOOL_ALIASES[name] = raw_name+ # The alias is the only name the model may emit, so the description is the one place+ # it can learn the name the server's docs and the user call this tool by.+ description = f"({raw_name}) {description}"+ else:+ # A name shipped as itself must not resolve through an alias it replaced.+ _MCP_TOOL_ALIASES.pop(name, None)specs.append({"type": "function","function": {"name": name,- "description": f"[{display}] {tool.get('description') or ''}".strip(),+ "description": f"[{display}] {description}".strip(),# mcp<2 dumps "inputSchema", 2.x "input_schema"; accept both."parameters": tool.get("inputSchema")or tool.get("input_schema")@@ -12580,9 +12630,10 @@ def execute_tool(if _mcp_arguments_reference_studio_credential(arguments):return _STUDIO_CREDENTIAL_BLOCKEDtry:- _, server_id, tool_name = name.split("__", 2)+ _, server_id, _ = name.split("__", 2)except ValueError:return f"Error: malformed MCP tool name '{name}'"+ tool_name = _mcp_raw_tool_name(name)server = mcp_servers_db.get_server_for_tool(server_id)if not server:return f"Error: MCP server for tool '{tool_name}' not found"diff --git a/studio/backend/tests/test_mcp_servers.py b/studio/backend/tests/test_mcp_servers.pyindex aa676d69998..cccac1a30c4 100644--- a/studio/backend/tests/test_mcp_servers.py+++ b/studio/backend/tests/test_mcp_servers.py@@ -525,7 +525,9 @@ def test_changes_from_payload_tristate_headers():# ── core/inference/tools: MCP wiring ────────────────────────────────-def test_mcp_specs_skip_oversized_names():+def test_mcp_specs_alias_oversized_names():+ import hashlib+from core.inference.tools import _mcp_specs_for_serverserver = {"id": "s" * 30, "display_name": "S"}@@ -534,9 +536,14 @@ def test_mcp_specs_skip_oversized_names():{"name": "x" * 40, "description": "too long"},]specs = _mcp_specs_for_server(server, tools)- assert len(specs) == 1- assert specs[0]["function"]["name"].endswith("__ok")- assert len(specs[0]["function"]["name"]) <= 64+ digest = hashlib.sha256(b"x" * 40).hexdigest()[:8]+ assert [spec["function"]["name"] for spec in specs] == [+ f"mcp__{'s' * 30}__ok",+ f"mcp__{'s' * 30}__{'x' * 18}_{digest}",+ ]+ assert len(specs[1]["function"]["name"]) == 64+ assert specs[1]["function"]["description"] == f"[S] ({'x' * 40}) too long"+ assert specs[0]["function"]["description"] == "[S] fine"def test_execute_tool_malformed_mcp_name():@@ -568,8 +575,10 @@ def test_execute_tool_disabled_server(tmp_path, monkeypatch):assert execute_tool("mcp__srv1__do_thing", {}) == "Error: MCP server 'A' is disabled"-def test_mcp_specs_skip_invalid_openai_function_names():+def test_mcp_specs_alias_invalid_openai_function_names():"""OpenAI requires function.name ^[a-zA-Z0-9_-]{1,64}$; bad names 400 the request."""+ import re+from core.inference.tools import _mcp_specs_for_serverserver = {"id": "srv", "display_name": "S"}@@ -580,9 +589,168 @@ def test_mcp_specs_skip_invalid_openai_function_names():{"name": "has space"},{"name": "good-dash_ok"},]- specs = _mcp_specs_for_server(server, tools)- names = {s["function"]["name"] for s in specs}- assert {"mcp__srv__ok", "mcp__srv__good-dash_ok"} == names+ names = [s["function"]["name"] for s in _mcp_specs_for_server(server, tools)]+ assert names[0] == "mcp__srv__ok"+ assert names[4] == "mcp__srv__good-dash_ok"+ assert [name.rsplit("_", 1)[0] for name in names[1:4]] == [+ "mcp__srv__with_dot",+ "mcp__srv__weird_slash",+ "mcp__srv__has_space",+ ]+ assert all(re.fullmatch(r"[a-zA-Z0-9_-]{1,64}", name) for name in names)+++def test_mcp_specs_aliases_stay_unique_and_never_take_a_valid_name():+ import hashlib++ from core.inference.tools import _mcp_specs_for_server++ taken = "with_dot_" + hashlib.sha256(b"with.dot").hexdigest()[:8]+ tools = [+ {"name": "a.b"},+ {"name": "a/b"},+ {"name": "a_b"},+ {"name": "with.dot"},+ {"name": taken},+ ]+ specs = _mcp_specs_for_server({"id": "srv", "display_name": "S"}, tools)+ assert [spec["function"]["name"] for spec in specs] == [+ "mcp__srv__a_b_" + hashlib.sha256(b"a.b").hexdigest()[:8],+ "mcp__srv__a_b_" + hashlib.sha256(b"a/b").hexdigest()[:8],+ "mcp__srv__a_b",+ f"mcp__srv__{taken}",+ ]+++def _cache_backstage_tools(tmp_path, monkeypatch, raw_names):+ from core.inference import mcp_client++ _reset_db(tmp_path, monkeypatch)+ monkeypatch.setattr(mcp_client, "_tool_cache", {})+ mcp_servers_db.create_server(+ id = "0123456789abcdef",+ display_name = "Backstage",+ url = "https://backstage/mcp",+ is_enabled = True,+ )+ tools = [{"name": name} for name in raw_names]+ mcp_client.cache_tools("0123456789abcdef", tools)+ return mcp_servers_db.get_server("0123456789abcdef"), tools+++def test_execute_tool_dispatches_an_alias_to_the_raw_mcp_name(tmp_path, monkeypatch):+ from core.inference import tools as tools_mod++ raw_names = [+ "get_weather",+ "catalog.get-catalog-entity",+ "summarize_repository_pull_request_review_comments",+ "get_repository_branch_protection_rules_v1",+ "get_repository_branch_protection_rules_v12",+ ]+ server, tools = _cache_backstage_tools(tmp_path, monkeypatch, raw_names)+ calls = []++ def fake_call_tool_sync(**kwargs):+ calls.append(kwargs["name"])+ return "ok"++ monkeypatch.setattr(tools_mod, "call_tool_sync", fake_call_tool_sync)+ names = [spec["function"]["name"] for spec in tools_mod._mcp_specs_for_server(server, tools)]+ assert names[0] == "mcp__0123456789abcdef__get_weather"+ assert names[3] == "mcp__0123456789abcdef__get_repository_branch_protection_rules_v1"+ assert len(set(names)) == 5+ assert [tools_mod.execute_tool(name, {}) for name in names] == ["ok"] * 5+ assert calls == raw_names+ # A deleted server must not put the alias spelling in front of the user either.+ mcp_servers_db.delete_server(server["id"])+ assert tools_mod.execute_tool(names[1], {}) == (+ "Error: MCP server for tool 'catalog.get-catalog-entity' not found"+ )+++def test_mcp_approval_classifies_an_alias_by_its_raw_name(tmp_path, monkeypatch):+ from core.inference import tools as tools_mod++ server, tools = _cache_backstage_tools(+ tmp_path, monkeypatch, ["get_repository_branch_protection_rules_then_delete"]+ )+ alias = tools_mod._mcp_specs_for_server(server, tools)[0]["function"]["name"]+ unresolved = "mcp__missing__" + alias.split("__", 2)[2]+ assert not tools_mod.is_potentially_unsafe_tool_call(unresolved, {})+ assert not tools_mod.is_high_risk_tool_call(unresolved, {})+ assert tools_mod.is_potentially_unsafe_tool_call(alias, {})+ assert tools_mod.is_high_risk_tool_call(alias, {})+++def test_mcp_alias_is_shown_to_the_user_by_its_raw_name(tmp_path, monkeypatch):+ from core.inference import studio_tool_loop+ from core.inference import tool_loop_controller as controller+ from core.inference.tools import _mcp_specs_for_server++ raw = "catalog.get-catalog-entity"+ server, tools = _cache_backstage_tools(tmp_path, monkeypatch, ["get_weather", raw])+ plain, alias = [spec["function"]["name"] for spec in _mcp_specs_for_server(server, tools)]+ assert alias != f"mcp__{server['id']}__{raw}"+ assert controller.mcp_display_parts(plain) == ("Backstage", "get_weather")+ assert controller.mcp_display_parts(alias) == ("Backstage", raw)+ assert controller.status_for_tool(alias, {}) == f"Calling: Backstage · {raw}"+ assert controller.awaiting_approval_status(alias) == f"Waiting for approval: Backstage · {raw}"+ decision = controller.ToolLoopController(tools = None).prepare_call(+ {"function": {"name": alias, "arguments": {}}}+ )+ for provenance in (+ decision.provenance,+ controller.provisional_tool_provenance(alias),+ studio_tool_loop._unrun_provenance(alias, 0),+ ):+ assert provenance["mcp_server"] == "Backstage"+ assert provenance["mcp_tool"] == raw+ assert controller.provisional_tool_provenance(plain)["mcp_tool"] == "get_weather"+++def test_in_flight_alias_still_dispatches_after_the_tool_cache_is_evicted(tmp_path, monkeypatch):+ from core.inference import mcp_client+ from core.inference import tool_loop_controller as controller+ from core.inference import tools as tools_mod++ server, tools = _cache_backstage_tools(+ tmp_path, monkeypatch, ["catalog.get-catalog-entity", "delete.catalog-entity"]+ )+ calls = []+ monkeypatch.setattr(+ tools_mod, "call_tool_sync", lambda **kwargs: calls.append(kwargs["name"]) or "ok"+ )+ names = [spec["function"]["name"] for spec in tools_mod._mcp_specs_for_server(server, tools)]+ mcp_servers_db.update_server(server["id"], {"headers_json": '{"Authorization": "Bearer new"}'})+ mcp_client.invalidate_tool_cache(server["id"])+ assert mcp_client.get_cached_tools(server["id"]) is None+ assert tools_mod.is_potentially_unsafe_tool_call(names[1], {})+ assert controller.mcp_display_parts(names[0]) == ("Backstage", "catalog.get-catalog-entity")+ assert tools_mod.execute_tool(names[0], {}) == "ok"+ assert calls == ["catalog.get-catalog-entity"]+++def test_a_direct_name_is_not_resolved_through_a_retired_alias(tmp_path, monkeypatch):+ import hashlib++ from core.inference import mcp_client+ from core.inference import tools as tools_mod++ monkeypatch.setattr(tools_mod, "_MCP_TOOL_ALIASES", {})+ server, tools = _cache_backstage_tools(tmp_path, monkeypatch, ["with.dot"])+ alias = tools_mod._mcp_specs_for_server(server, tools)[0]["function"]["name"]+ taken = "with_dot_" + hashlib.sha256(b"with.dot").hexdigest()[:8]+ assert alias == f"mcp__{server['id']}__{taken}"+ calls = []+ monkeypatch.setattr(+ tools_mod, "call_tool_sync", lambda **kwargs: calls.append(kwargs["name"]) or "ok"+ )+ refreshed = [{"name": taken}]+ mcp_client.cache_tools(server["id"], refreshed)+ assert tools_mod._mcp_specs_for_server(server, refreshed)[0]["function"]["name"] == alias+ assert tools_mod.execute_tool(alias, {}) == "ok"+ assert calls == [taken]def test_mcp_specs_skip_empty_tool_name():diff --git a/studio/backend/tests/test_permission_mode.py b/studio/backend/tests/test_permission_mode.pyindex fa7cfbe88f8..e11e01f10c9 100644--- a/studio/backend/tests/test_permission_mode.py+++ b/studio/backend/tests/test_permission_mode.py@@ -3256,6 +3256,33 @@ def test_auto_mode_prompts_on_dangerous_mcp_work(name):assert is_high_risk_tool_call(f"{MCP_TOOL_PREFIX}{name}", {"code": "x"}) is True+# An MCP name may separate its terms with any character the spec allows, and those names now ship to the+# model under an alias instead of being dropped. The classifier reads the raw name, so a verb behind a "."+# or a " " has to weigh exactly as much as the same verb behind a "_".+ "dotted, underscored",+ [+ ("get_file.delete", "get_file_delete"),+ ("read_file.secret", "read_file_secret"),+ ("delete.catalog-entity", "delete_catalog_entity"),+ ("fetch:api.key", "fetch_api_key"),+ ("get file/secret", "get_file_secret"),+ ("catalog.get-catalog-entity", "catalog_get_catalog_entity"),+ ("list.issues", "list_issues"),+ ("search.catalog-entities", "search_catalog_entities"),+ ],+)+def test_a_separator_never_changes_what_an_mcp_name_classifies_as(dotted, underscored):+ from core.inference.tools import _mcp_specs_for_server++ server = {"id": "0123456789abcdef", "display_name": "S"}+ specs = _mcp_specs_for_server(server, [{"name": dotted}])+ alias = specs[0]["function"]["name"]+ plain = f"{MCP_TOOL_PREFIX}{server['id']}__{underscored}"+ assert is_high_risk_tool_call(alias, {}) is is_high_risk_tool_call(plain, {})+ assert is_potentially_unsafe_tool_call(alias, {}) is is_potentially_unsafe_tool_call(plain, {})++# The reported sandbox escape (HF discussion #107, Desktop v0.1.808-beta): the session sandbox directory is a working# directory, not an OS boundary, so an ABSOLUTE path in a tool call reaches the user's real filesystem with their own# permissions. Deletion already prompted; reading and overwriting did not. These are the reporter's own operations,diff --git a/studio/frontend/src/components/assistant-ui/message-response-details-sheet.tsx b/studio/frontend/src/components/assistant-ui/message-response-details-sheet.tsxindex 2ef11d14e0f..e8490d71407 100644--- a/studio/frontend/src/components/assistant-ui/message-response-details-sheet.tsx+++ b/studio/frontend/src/components/assistant-ui/message-response-details-sheet.tsx@@ -19,6 +19,7 @@ import {useExternalProvidersStore,formatMcpToolName,mcpServerFromProvenance,+ mcpToolFromProvenance,} from "@/features/chat";import { FIND_SKIP_ATTRIBUTE } from "@/features/find-in-page";import { cn } from "@/lib/utils";@@ -135,10 +136,14 @@ function toolCategoryFromCall(toolName: string): string | null {return null;}-function formatToolCallName(toolName: string, mcpServer?: string): string {+function formatToolCallName(toolName: string, provenance?: unknown): string {const normalized = toolName.toLowerCase();if (TOOL_CALL_LABELS[normalized]) return TOOL_CALL_LABELS[normalized];- const mcpLabel = formatMcpToolName(toolName, mcpServer);+ const mcpLabel = formatMcpToolName(+ toolName,+ mcpServerFromProvenance(provenance),+ mcpToolFromProvenance(provenance),+ );if (mcpLabel) return `MCP: ${mcpLabel}`;// Malformed but still MCP: keep the prefix so the category check agrees.if (normalized.startsWith("mcp__")) return `MCP: ${toolName.slice(5)}`;@@ -166,17 +171,18 @@ function toolCallsFromContent(content: unknown): string[] {);}-function mcpServersFromContent(content: unknown): Map<string, string> {- const servers = new Map<string, string>();- if (!Array.isArray(content)) return servers;+function mcpProvenanceFromContent(content: unknown): Map<string, unknown> {+ const provenance = new Map<string, unknown>();+ if (!Array.isArray(content)) return provenance;for (const part of content) {if (!part || typeof part !== "object") continue;const p = part as { type?: unknown; toolName?: unknown; provenance?: unknown };if (p.type !== "tool-call" || typeof p.toolName !== "string") continue;- const server = mcpServerFromProvenance(p.provenance);- if (server) servers.set(p.toolName, server);+ if (mcpServerFromProvenance(p.provenance)) {+ provenance.set(p.toolName, p.provenance);+ }}- return servers;+ return provenance;}function enabledTools(@@ -200,11 +206,11 @@ function enabledTools(function calledTools(toolCalls: string[],- mcpServers: Map<string, string>,+ mcpProvenance: Map<string, unknown>,): string | null {if (toolCalls.length === 0) return null;return uniqueValues(- toolCalls.map((name) => formatToolCallName(name, mcpServers.get(name))),+ toolCalls.map((name) => formatToolCallName(name, mcpProvenance.get(name))),).join(", ");}@@ -365,7 +371,7 @@ export const MessageResponseDetailsSheet: FC<{const summaryLabel =modelLabel === "Not recorded" ? "Model not recorded" : `Used ${modelLabel}`;const messageToolCalls = toolCallsFromContent(message.content);- const mcpServers = mcpServersFromContent(message.content);+ const mcpProvenance = mcpProvenanceFromContent(message.content);const toolCalls =responseDetails?.toolCalls && responseDetails.toolCalls.length > 0? responseDetails.toolCalls@@ -500,7 +506,7 @@ export const MessageResponseDetailsSheet: FC<{label="Enabled"value={enabledTools(responseDetails?.tools, toolCalls)}/>- <DetailRow label="Called" value={calledTools(toolCalls, mcpServers)} />+ <DetailRow label="Called" value={calledTools(toolCalls, mcpProvenance)} /><DetailRowlabel="Confirmation"value={diff --git a/studio/frontend/src/components/assistant-ui/tool-fallback.tsx b/studio/frontend/src/components/assistant-ui/tool-fallback.tsxindex 84131d9e5a8..80ad7e8ced5 100644--- a/studio/frontend/src/components/assistant-ui/tool-fallback.tsx+++ b/studio/frontend/src/components/assistant-ui/tool-fallback.tsx@@ -15,6 +15,7 @@ import { useCollapseScrollLock } from "@/hooks/use-collapse-scroll-lock";import {formatMcpToolName,mcpServerFromProvenance,+ mcpToolFromProvenance,} from "@/features/chat/utils/mcp-tool-name";import { stripAnsi, stringifyToolResult } from "@/lib/strip-ansi";import { cn } from "@/lib/utils";@@ -154,6 +155,7 @@ const statusIconMap: Record<ToolStatus, ElementType> = {function ToolFallbackTrigger({toolName,mcpServer,+ mcpTool,status,icon: ToolIcon,className,@@ -164,6 +166,7 @@ function ToolFallbackTrigger({// lands HERE, where formatMcpToolName calls `.startsWith` on it.toolName: unknown;mcpServer?: string;+ mcpTool?: string;status?: ToolCallMessagePartStatus;icon?: ElementType;}) {@@ -174,7 +177,7 @@ function ToolFallbackTrigger({const StatusIcon = statusIconMap[statusType];const label = toolFallbackLabel(status);const name = toolArgText(toolName);- const displayName = formatMcpToolName(name, mcpServer) ?? name;+ const displayName = formatMcpToolName(name, mcpServer, mcpTool) ?? name;return (<CollapsibleTrigger@@ -423,16 +426,15 @@ const ToolFallbackImpl: ToolCallMessagePartComponent = ({// Allow/Deny confirmation controls are rendered uniformly for every tool// card (built-in and fallback) by the `withToolConfirmation` wrapper in// thread.tsx, so this renderer stays purely presentational.- const mcpServer = mcpServerFromProvenance(- (rest as { provenance?: unknown }).provenance,- );+ const provenance = (rest as { provenance?: unknown }).provenance;const isCancelled = isToolCallCancelled(status);return (<ToolFallbackRoot className={cn(isCancelled && "bg-muted/30")}><ToolFallbackTriggertoolName={toolName}- mcpServer={mcpServer}+ mcpServer={mcpServerFromProvenance(provenance)}+ mcpTool={mcpToolFromProvenance(provenance)}status={status}/><ToolFallbackContent>diff --git a/studio/frontend/src/features/chat/hooks/use-chat-search-index.ts b/studio/frontend/src/features/chat/hooks/use-chat-search-index.tsindex 8b1e4e008aa..18972b7f9d0 100644--- a/studio/frontend/src/features/chat/hooks/use-chat-search-index.ts+++ b/studio/frontend/src/features/chat/hooks/use-chat-search-index.ts@@ -27,6 +27,7 @@ import {import {formatMcpToolName,mcpServerFromProvenance,+ mcpToolFromProvenance,} from "../utils/mcp-tool-name";import { attachmentsPastedText } from "../utils/pasted-text.ts";@@ -130,7 +131,11 @@ function extractText(message: MessageRecord): string {// Index the rendered "Server · tool" label too, so pasting it matches.const label =typeof p.toolName === "string"- ? formatMcpToolName(p.toolName, mcpServer)+ ? formatMcpToolName(+ p.toolName,+ mcpServer,+ mcpToolFromProvenance(p.provenance),+ ): null;if (label) parts.push(label);}diff --git a/studio/frontend/src/features/chat/index.ts b/studio/frontend/src/features/chat/index.tsindex f2b102a09c6..20ed71d22b8 100644--- a/studio/frontend/src/features/chat/index.ts+++ b/studio/frontend/src/features/chat/index.ts@@ -236,6 +236,7 @@ export { YoutubeTranscriptPrompt } from "./components/youtube-transcript-prompt"export {formatMcpToolName,mcpServerFromProvenance,+ mcpToolFromProvenance,} from "./utils/mcp-tool-name";export {PASTED_TEXT_PREVIEW_MAX_CHARS,diff --git a/studio/frontend/src/features/chat/utils/conversation-markdown.ts b/studio/frontend/src/features/chat/utils/conversation-markdown.tsindex 6bff0817310..baab285e49b 100644--- a/studio/frontend/src/features/chat/utils/conversation-markdown.ts+++ b/studio/frontend/src/features/chat/utils/conversation-markdown.ts@@ -1,7 +1,11 @@// SPDX-License-Identifier: AGPL-3.0-only// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0-import { formatMcpToolName, mcpServerFromProvenance } from "./mcp-tool-name.ts";+import {+ formatMcpToolName,+ mcpServerFromProvenance,+ mcpToolFromProvenance,+} from "./mcp-tool-name.ts";export type ConversationMarkdownMessage = {readonly role: string;@@ -560,8 +564,11 @@ export function contentBlocksToMarkdownBlocks(blocks.push({kind: "tool-call",name:- formatMcpToolName(toolName, mcpServerFromProvenance(p.provenance)) ??- toolName,+ formatMcpToolName(+ toolName,+ mcpServerFromProvenance(p.provenance),+ mcpToolFromProvenance(p.provenance),+ ) ?? toolName,args: withoutNativePartBytes(p.args),result: withoutGeneratedImageBytes(normalizeToolResult(p.result, toolName),diff --git a/studio/frontend/src/features/chat/utils/mcp-tool-name.ts b/studio/frontend/src/features/chat/utils/mcp-tool-name.tsindex 2a0682e9350..aeebdc49969 100644--- a/studio/frontend/src/features/chat/utils/mcp-tool-name.ts+++ b/studio/frontend/src/features/chat/utils/mcp-tool-name.ts@@ -3,21 +3,34 @@const MCP_TOOL_PREFIX = "mcp__";-/** The server display name stamped into tool-call provenance by the backend. */-export function mcpServerFromProvenance(provenance: unknown): string | undefined {+function provenanceString(+ provenance: unknown,+ key: "mcp_server" | "mcp_tool",+): string | undefined {if (!provenance || typeof provenance !== "object") return undefined;- const value = (provenance as { mcp_server?: unknown }).mcp_server;+ const value = (provenance as Record<string, unknown>)[key];return typeof value === "string" && value ? value : undefined;}-/** "GitHub · create_issue" for mcp__<serverId>__<tool>, else null. Falls back to the raw id. */+/** The server display name stamped into tool-call provenance by the backend. */+export function mcpServerFromProvenance(provenance: unknown): string | undefined {+ return provenanceString(provenance, "mcp_server");+}++/** The raw MCP tool name; an aliased tool's composed name no longer spells it. */+export function mcpToolFromProvenance(provenance: unknown): string | undefined {+ return provenanceString(provenance, "mcp_tool");+}++/** "GitHub · create_issue" for mcp__<serverId>__<tool>, else null. Falls back to the raw parts. */export function formatMcpToolName(toolName: string,mcpServer?: string,+ mcpTool?: string,): string | null {if (!toolName.startsWith(MCP_TOOL_PREFIX)) return null;const rest = toolName.slice(MCP_TOOL_PREFIX.length);const sep = rest.indexOf("__");if (sep <= 0) return null;- return `${mcpServer || rest.slice(0, sep)} · ${rest.slice(sep + 2)}`;+ return `${mcpServer || rest.slice(0, sep)} · ${mcpTool || rest.slice(sep + 2)}`;}diff --git a/studio/frontend/tests/conversation-markdown.test.ts b/studio/frontend/tests/conversation-markdown.test.tsindex f30a3e04d76..1e206a47b78 100644--- a/studio/frontend/tests/conversation-markdown.test.ts+++ b/studio/frontend/tests/conversation-markdown.test.ts@@ -228,6 +228,25 @@ test("collapses thinking and leaves prose untouched", () => {);});+test("an exported MCP tool call is named the way the server names it", () => {+ const blocks = contentBlocksToMarkdownBlocks([+ {+ type: "tool-call",+ toolName: "mcp__0123456789abcdef__catalog_get-catalog-entity_b9d734f2",+ provenance: {+ mcp_server: "Backstage Catalog",+ mcp_tool: "catalog.get-catalog-entity",+ },+ },+ ]);++ assert.match(+ renderConversationBlocks(blocks),+ /Backstage Catalog · catalog\.get-catalog-entity/,+ );+ assert.doesNotMatch(renderConversationBlocks(blocks), /b9d734f2/);+});+test("omits generated image bytes while retaining useful result metadata", () => {const blocks = contentBlocksToMarkdownBlocks([{diff --git a/studio/frontend/tests/mcp-tool-name.test.ts b/studio/frontend/tests/mcp-tool-name.test.tsindex 55bd9f55de5..bb3b1b3d826 100644--- a/studio/frontend/tests/mcp-tool-name.test.ts+++ b/studio/frontend/tests/mcp-tool-name.test.ts@@ -7,8 +7,35 @@ import test from "node:test";import {formatMcpToolName,mcpServerFromProvenance,+ mcpToolFromProvenance,} from "../src/features/chat/utils/mcp-tool-name.ts";+test("an aliased MCP tool shows the real tool name stamped in provenance", () => {+ const provenance = {+ mcp_server: "Backstage Catalog",+ mcp_tool: "catalog.get-catalog-entity",+ };+ assert.equal(+ formatMcpToolName(+ "mcp__0123456789abcdef__catalog_get-catalog-entity_b9d734f2",+ mcpServerFromProvenance(provenance),+ mcpToolFromProvenance(provenance),+ ),+ "Backstage Catalog · catalog.get-catalog-entity",+ );+});++test("reads mcp_tool from provenance, string-only", () => {+ assert.equal(+ mcpToolFromProvenance({ mcp_tool: "catalog.get-catalog-entity" }),+ "catalog.get-catalog-entity",+ );+ assert.equal(mcpToolFromProvenance({ mcp_tool: "" }), undefined);+ assert.equal(mcpToolFromProvenance({ mcp_tool: 3 }), undefined);+ assert.equal(mcpToolFromProvenance({ mcp_server: "GitHub" }), undefined);+ assert.equal(mcpToolFromProvenance(undefined), undefined);+});+test("formats an MCP name with the stamped server name", () => {assert.equal(formatMcpToolName("mcp__a3f9c1d2e4b6f807__create_issue", "GitHub"),diff --git a/studio/frontend/tests/tool-card-arg-coercion.test.ts b/studio/frontend/tests/tool-card-arg-coercion.test.tsindex 2edf2f0c33b..a8cfdccb6c7 100644--- a/studio/frontend/tests/tool-card-arg-coercion.test.ts+++ b/studio/frontend/tests/tool-card-arg-coercion.test.ts@@ -307,7 +307,7 @@ test("the fallback card survives a tool name that is not a string", () => {);assert.match(source,- /formatMcpToolName\(name, mcpServer\) \?\? name/,+ /formatMcpToolName\(name, mcpServer, mcpTool\) \?\? name/,"tool-fallback.tsx passes the raw toolName to formatMcpToolName",);assert.equal(toolArgText(123).startsWith("mcp__"), false);