Skip to content

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.

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.py
index 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 provenance
diff --git a/studio/backend/core/inference/tool_loop_controller.py b/studio/backend/core/inference/tool_loop_controller.py
index 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 None
try:
+ from core.inference.tools import _mcp_raw_tool_name
from 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 None
except Exception: # noqa: BLE001
return None
- display = (server or {}).get("display_name")
- return (str(display), parts[2]) if display else None
def 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.py
index 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 + 1
def _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)
continue
seen_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_BLOCKED
try:
- _, 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.py
index 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_server
server = {"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_server
server = {"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.py
index 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.tsx
index 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)} />
<DetailRow
label="Confirmation"
value={
diff --git a/studio/frontend/src/components/assistant-ui/tool-fallback.tsx b/studio/frontend/src/components/assistant-ui/tool-fallback.tsx
index 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")}>
<ToolFallbackTrigger
toolName={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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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);