diff --git a/.env.example b/.env.example
index 4e072eeaf9..c4fa979563 100644
--- a/.env.example
+++ b/.env.example
@@ -3023,8 +3023,8 @@ PLUGINS_CLI_MARKUP_MODE=rich
 # Unsafe URI pattern
 # VALIDATION_UNSAFE_URI_PATTERN="[<>\"'\\]"
 
-# MCP tool naming pattern per SEP-986
-# VALIDATION_TOOL_NAME_PATTERN="^[a-zA-Z0-9_][a-zA-Z0-9._/-]*$"
+# MCP tool naming pattern
+# VALIDATION_TOOL_NAME_PATTERN="^[a-zA-Z0-9_.-]+$"
 
 # MCP tool method naming pattern
 # VALIDATION_TOOL_METHOD_PATTERN="^[a-zA-Z][a-zA-Z0-9_\\./-]*$"
diff --git a/.secrets.baseline b/.secrets.baseline
index ccf0853d47..900fe0dd23 100644
--- a/.secrets.baseline
+++ b/.secrets.baseline
@@ -3,7 +3,7 @@
     "files": "(?x)( package-lock\\.json$ |Cargo\\.lock$ |uv\\.lock$ |go\\.sum$ |mcpgateway/sri_hashes\\.json$ )|^.secrets.baseline$",
     "lines": null
   },
-  "generated_at": "2026-07-21T16:03:44Z",
+  "generated_at": "2026-07-22T13:20:53Z",
   "plugins_used": [
     {
       "name": "AWSKeyDetector"
@@ -266,7 +266,7 @@
         "hashed_secret": "b4673e578b9b30fe8bba1b555b7b59883444c697",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 1889,
+        "line_number": 1891,
         "type": "Secret Keyword",
         "verified_result": null
       },
@@ -274,7 +274,7 @@
         "hashed_secret": "4a0a2df96d4c9a13a282268cab33ac4b8cbb2c72",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 1977,
+        "line_number": 1979,
         "type": "Secret Keyword",
         "verified_result": null
       },
@@ -282,7 +282,7 @@
         "hashed_secret": "5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 2327,
+        "line_number": 2329,
         "type": "Basic Auth Credentials",
         "verified_result": null
       },
@@ -290,7 +290,7 @@
         "hashed_secret": "fa9beb99e4029ad5a6615399e7bbae21356086b3",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 3692,
+        "line_number": 3694,
         "type": "Basic Auth Credentials",
         "verified_result": null
       },
@@ -298,7 +298,7 @@
         "hashed_secret": "fa9beb99e4029ad5a6615399e7bbae21356086b3",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 3783,
+        "line_number": 3785,
         "type": "Secret Keyword",
         "verified_result": null
       },
@@ -306,7 +306,7 @@
         "hashed_secret": "ac371b6dcce28a86c90d12bc57d946a800eebf17",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 3826,
+        "line_number": 3828,
         "type": "Secret Keyword",
         "verified_result": null
       },
@@ -314,7 +314,7 @@
         "hashed_secret": "0b6ec68df700dec4dcd64babd0eda1edccddace1",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 3831,
+        "line_number": 3833,
         "type": "Secret Keyword",
         "verified_result": null
       },
@@ -322,7 +322,7 @@
         "hashed_secret": "4ad6f0082ee224001beb3ca5c3e81c8ceea5ed86",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 3836,
+        "line_number": 3838,
         "type": "Secret Keyword",
         "verified_result": null
       }
@@ -3838,7 +3838,7 @@
         "hashed_secret": "c377074d6473f35a91001981355da793dc808ffd",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 749,
+        "line_number": 746,
         "type": "Hex High Entropy String",
         "verified_result": null
       }
@@ -3874,7 +3874,7 @@
         "hashed_secret": "c377074d6473f35a91001981355da793dc808ffd",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 4576,
+        "line_number": 4580,
         "type": "Hex High Entropy String",
         "verified_result": null
       }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c1dc9cbabb..fda6660298 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -60,6 +60,8 @@ Release 1.0.6 consolidates **61 PRs** focused on **OAuth RFC 8693 token exchange
 
 ### Changed
 
+- **MCP Tool Names and Virtual-Server Aliases** ([#5553](https://github.com/IBM/mcp-context-forge/pull/5553)) - Virtual servers now expose custom tool names and resolve them to upstream names. Tool names follow the MCP 2025-11-25 character set and 128-character limit, with full-string validation that also rejects trailing newlines. **Breaking:** slash-delimited tool names are no longer accepted; rename them to use letters, numbers, periods, underscores, or hyphens.
+
 #### **API**
 
 - **Custom Auth Headers on Tools** ([#5314](https://github.com/IBM/mcp-context-forge/pull/5314)) - `POST /tools` and `PUT /tools/{tool_id}` now correctly persist the `auth_headers` array instead of silently storing `auth_value: null`. Invalid header keys/values are rejected with a 422 rather than an unhandled 500.
diff --git a/docs/docs/testing/acceptance.md b/docs/docs/testing/acceptance.md
index 11c8f51309..34e30c4436 100644
--- a/docs/docs/testing/acceptance.md
+++ b/docs/docs/testing/acceptance.md
@@ -352,11 +352,11 @@ MCPGATEWAY_ADMIN_API_ENABLED=true
 
 | Feature | URL | Commands | Expected Result | Status | Notes |
 |---------|-----|----------|-----------------|--------|-------|
-| XSS in Tool Name | `curl -X POST $GW_URL/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/json" -d '{"name": "<script>alert(1)</script>", "url": "https://example.com"}'` | Attempt XSS | 422 - `"Tool name must start with a letter, number, or underscore and contain only letters, numbers, periods, underscores, hyphens, and slashes"` | ☐ | Input sanitization |
+| XSS in Tool Name | `curl -X POST $GW_URL/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/json" -d '{"name": "<script>alert(1)</script>", "url": "https://example.com"}'` | Attempt XSS | 422 - `"Tool name may contain only letters, numbers, underscores, hyphens, and periods"` | ☐ | Input sanitization |
 | SQL Injection Pattern | `curl -X POST $GW_URL/admin/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/x-www-form-urlencoded" -d 'name=tool"; DROP TABLE tools; --&url=https://example.com&integrationType=REST&requestType=GET'` | SQL injection | 400/500 - Validation error | ☐ | Pattern blocked |
 | Invalid URL Scheme | `curl -X POST $GW_URL/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/json" -d '{"name": "test_tool", "url": "javascript:alert(1)"}'` | JavaScript URL | 422 - `"Tool URL must start with one of: http://, https://, ws://, wss://"` | ☐ | URL validation |
 | Directory Traversal | `curl -X POST $GW_URL/admin/resources -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/x-www-form-urlencoded" -d 'uri=../../etc/passwd&name=test&content=data'` | Path traversal | 500 - `"Resource URI cannot contain directory traversal sequences"` | ☐ | Path validation |
-| Name Too Long | `curl -X POST $GW_URL/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/json" -d '{"name": "'"$(printf 'a%.0s' {1..300})"'", "url": "https://example.com"}'` | 300 char name | 422 - `"Tool name exceeds maximum length of 255"` | ☐ | Length validation |
+| Name Too Long | `curl -X POST $GW_URL/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/json" -d '{"name": "'"$(printf 'a%.0s' {1..300})"'", "url": "https://example.com"}'` | 300 char name | 422 - `"Tool name exceeds MCP spec limit of 128 characters"` | ☐ | Length validation |
 | Empty Required Field | `curl -X POST $GW_URL/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/json" -d '{"name": "", "url": "https://example.com"}'` | Empty name | 422 - `"Tool name cannot be empty"` | ☐ | Required validation |
 | Whitespace Only | `curl -X POST $GW_URL/tools -H "Authorization: Bearer $MCPGATEWAY_BEARER_TOKEN" -H "Content-Type: application/json" -d '{"name": "   ", "url": "https://example.com"}'` | Spaces only | 422 - `"Tool name cannot be empty"` | ☐ | Trimming validation |
 
diff --git a/mcpgateway/admin.py b/mcpgateway/admin.py
index 725662b17b..a24f6f32e8 100644
--- a/mcpgateway/admin.py
+++ b/mcpgateway/admin.py
@@ -18383,8 +18383,7 @@ async def get_observability_traces(
     user_email: QueryUserIdentifierNoDescription = None,
     name_search: Optional[str] = Query(None, max_length=500),
     attribute_search: Optional[str] = Query(None, max_length=500),
-    # tool_name pattern follows MCP SEP-986 (Specify Format for Tool Names), matching
-    # mcpgateway.config.Settings.validation_tool_name_pattern. Allows namespacing via '/'.
+    # tool_name follows mcpgateway.config.Settings.validation_tool_name_pattern.
     tool_name: QueryToolName = None,
     _user=Depends(get_current_user_with_permissions),
     db: Session = Depends(get_db),
diff --git a/mcpgateway/cache/registry_cache.py b/mcpgateway/cache/registry_cache.py
index fe031315a1..0a46d96c3c 100644
--- a/mcpgateway/cache/registry_cache.py
+++ b/mcpgateway/cache/registry_cache.py
@@ -873,6 +873,8 @@ class CacheInvalidationSubscriber:
         - registry:{cache_type} - Invalidate registry cache (tools, prompts, etc.)
         - tool_lookup:{name} - Invalidate specific tool lookup
         - tool_lookup:gateway:{gateway_id} - Invalidate all tools for a gateway
+        - tool_lookup:server:{server_id} - Invalidate all tools scoped to a virtual server
+        - tool_lookup:scoped - Invalidate all virtual-server-scoped tool lookups
         - admin:{prefix} - Invalidate admin stats cache
         - user:{email} - Invalidate auth user cache
         - revoke:{jti} - Invalidate auth revocation cache
@@ -1061,6 +1063,30 @@ async def _process_invalidation(self, message: str, *, channel: str = "") -> Non
                         cache._cache.pop(key, None)  # pyright: ignore[reportPrivateUsage]
                 logger.debug("CacheInvalidationSubscriber: Cleared local registry:%s cache (%d keys)", cache_type, len(keys_to_remove))
 
+            elif message == "tool_lookup:scoped":
+                # Handle all virtual-server-scoped tool lookup invalidation
+                # First-Party
+                from mcpgateway.cache.tool_lookup_cache import tool_lookup_cache  # pylint: disable=import-outside-toplevel
+
+                with tool_lookup_cache._lock:  # pyright: ignore[reportPrivateUsage]
+                    to_remove = [name for name in tool_lookup_cache._cache if name.startswith("server:")]  # pyright: ignore[reportPrivateUsage]
+                    for name in to_remove:
+                        tool_lookup_cache._cache.pop(name, None)  # pyright: ignore[reportPrivateUsage]
+                logger.debug("CacheInvalidationSubscriber: Cleared all local scoped tool lookups (%d keys)", len(to_remove))
+
+            elif message.startswith("tool_lookup:server:"):
+                # Handle virtual-server-scoped tool lookup invalidation
+                server_id = message[len("tool_lookup:server:") :]
+                # First-Party
+                from mcpgateway.cache.tool_lookup_cache import tool_lookup_cache  # pylint: disable=import-outside-toplevel
+
+                key_prefix = tool_lookup_cache._cache_key("", server_id)  # pyright: ignore[reportPrivateUsage]
+                with tool_lookup_cache._lock:  # pyright: ignore[reportPrivateUsage]
+                    to_remove = [name for name in tool_lookup_cache._cache if name.startswith(key_prefix)]  # pyright: ignore[reportPrivateUsage]
+                    for name in to_remove:
+                        tool_lookup_cache._cache.pop(name, None)  # pyright: ignore[reportPrivateUsage]
+                logger.debug("CacheInvalidationSubscriber: Cleared local tool_lookup for server %s (%d keys)", server_id, len(to_remove))
+
             elif message.startswith("tool_lookup:gateway:"):
                 # Handle gateway-wide tool lookup invalidation
                 gateway_id = message[len("tool_lookup:gateway:") :]
diff --git a/mcpgateway/cache/tool_lookup_cache.py b/mcpgateway/cache/tool_lookup_cache.py
index c7a7ff950e..c33ea3e99d 100644
--- a/mcpgateway/cache/tool_lookup_cache.py
+++ b/mcpgateway/cache/tool_lookup_cache.py
@@ -54,7 +54,7 @@ def is_expired(self) -> bool:
 
 
 class ToolLookupCache:
-    """Two-tier cache for tool lookups by name.
+    """Two-tier cache for global or virtual-server-scoped tool lookups.
 
     L1: in-memory LRU/TTL per worker.
     L2: Redis (optional, shared across workers).
@@ -131,6 +131,19 @@ def _redis_key(self, name: str) -> str:
         """
         return f"{self._cache_prefix}tool_lookup:{name}"
 
+    @staticmethod
+    def _cache_key(name: str, server_id: Optional[str] = None) -> str:
+        """Build an internal cache key for a global or server-scoped lookup.
+
+        Args:
+            name: Requested tool name.
+            server_id: Optional virtual server scope.
+
+        Returns:
+            An internal cache key that isolates aliases between virtual servers.
+        """
+        return f"server:{server_id}:{name}" if server_id else name
+
     def _gateway_set_key(self, gateway_id: str) -> str:
         """Build the Redis set key for tools in a gateway.
 
@@ -142,7 +155,26 @@ def _gateway_set_key(self, gateway_id: str) -> str:
         """
         return f"{self._cache_prefix}tool_lookup:gateway:{gateway_id}"
 
-    async def _get_redis_client(self):
+    def _server_set_key(self, server_id: str) -> str:
+        """Build the Redis set key for cached lookups in a virtual server.
+
+        Args:
+            server_id: Virtual server ID.
+
+        Returns:
+            Redis set key for server-scoped lookup keys.
+        """
+        return f"{self._cache_prefix}tool_lookup:server:{server_id}"
+
+    def _scoped_set_key(self) -> str:
+        """Build the Redis set key for all virtual-server-scoped lookups.
+
+        Returns:
+            Redis set key for all server-scoped lookup keys.
+        """
+        return f"{self._cache_prefix}tool_lookup_index:scoped"
+
+    async def _get_redis_client(self) -> Any:
         """Return a Redis client if L2 is enabled and available.
 
         Returns:
@@ -201,11 +233,12 @@ def _set_l1(self, name: str, value: Dict[str, Any], ttl: int) -> None:
                 self._cache.popitem(last=False)
             self._cache[name] = CacheEntry(value=value, expiry=time.time() + ttl)
 
-    async def get(self, name: str) -> Optional[Dict[str, Any]]:
-        """Get cached payload for a tool name, checking L1 then L2.
+    async def get(self, name: str, server_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """Get a cached payload for a global or server-scoped tool name.
 
         Args:
             name: Tool name.
+            server_id: Optional virtual server scope.
 
         Returns:
             Cached payload dict or None.
@@ -225,7 +258,8 @@ async def get(self, name: str) -> Optional[Dict[str, Any]]:
         if not self._enabled:
             return None
 
-        cached = self._get_l1(name)
+        cache_key = self._cache_key(name, server_id)
+        cached = self._get_l1(cache_key)
         if cached is not None:
             return cached
 
@@ -234,25 +268,33 @@ async def get(self, name: str) -> Optional[Dict[str, Any]]:
             return None
 
         try:
-            data = await redis.get(self._redis_key(name))
+            data = await redis.get(self._redis_key(cache_key))
             if data:
                 self._l2_hit_count += 1
-                payload = orjson.loads(data)
-                self._set_l1(name, payload, self._ttl_seconds)
+                payload: Dict[str, Any] = orjson.loads(data)
+                self._set_l1(cache_key, payload, self._ttl_seconds)
                 return payload
             self._l2_miss_count += 1
         except Exception as exc:
             logger.debug("ToolLookupCache Redis get failed: %s", exc)
         return None
 
-    async def set(self, name: str, payload: Dict[str, Any], ttl: Optional[int] = None, gateway_id: Optional[str] = None) -> None:
-        """Store a payload in cache and update gateway index if provided.
+    async def set(
+        self,
+        name: str,
+        payload: Dict[str, Any],
+        ttl: Optional[int] = None,
+        gateway_id: Optional[str] = None,
+        server_id: Optional[str] = None,
+    ) -> None:
+        """Store a payload in cache and update invalidation indexes.
 
         Args:
             name: Tool name.
             payload: Payload to cache.
             ttl: Time to live in seconds (defaults to configured TTL).
             gateway_id: Gateway ID for invalidation set tracking.
+            server_id: Optional virtual server scope and invalidation index.
 
         Examples:
             >>> import asyncio
@@ -268,27 +310,34 @@ async def set(self, name: str, payload: Dict[str, Any], ttl: Optional[int] = Non
             return
 
         effective_ttl = ttl if ttl is not None else self._ttl_seconds
-        self._set_l1(name, payload, effective_ttl)
+        cache_key = self._cache_key(name, server_id)
+        self._set_l1(cache_key, payload, effective_ttl)
 
         redis = await self._get_redis_client()
         if not redis:
             return
 
         try:
-            await redis.setex(self._redis_key(name), effective_ttl, orjson.dumps(payload))
+            await redis.setex(self._redis_key(cache_key), effective_ttl, orjson.dumps(payload))
             if gateway_id:
                 set_key = self._gateway_set_key(gateway_id)
-                await redis.sadd(set_key, name)
+                await redis.sadd(set_key, cache_key)
                 await redis.expire(set_key, max(effective_ttl, self._ttl_seconds))
+            if server_id:
+                for set_key in (self._server_set_key(server_id), self._scoped_set_key()):
+                    await redis.sadd(set_key, cache_key)
+                    await redis.expire(set_key, max(effective_ttl, self._ttl_seconds))
         except Exception as exc:
             logger.debug("ToolLookupCache Redis set failed: %s", exc)
 
-    async def set_negative(self, name: str, status: str) -> None:
+    async def set_negative(self, name: str, status: str, gateway_id: Optional[str] = None, server_id: Optional[str] = None) -> None:
         """Store a negative cache entry for a tool name.
 
         Args:
             name: Tool name.
             status: Negative status (missing, inactive, offline).
+            gateway_id: Optional gateway ID for invalidation tracking.
+            server_id: Optional virtual server scope.
 
         Examples:
             >>> import asyncio
@@ -301,14 +350,15 @@ async def set_negative(self, name: str, status: str) -> None:
             {'status': 'missing'}
         """
         payload = {"status": status}
-        await self.set(name=name, payload=payload, ttl=self._negative_ttl_seconds)
+        await self.set(name=name, payload=payload, ttl=self._negative_ttl_seconds, gateway_id=gateway_id, server_id=server_id)
 
-    async def invalidate(self, name: str, gateway_id: Optional[str] = None) -> None:
+    async def invalidate(self, name: str, gateway_id: Optional[str] = None, server_id: Optional[str] = None) -> None:
         """Invalidate a tool cache entry by name.
 
         Args:
             name: Tool name.
-            gateway_id: Gateway ID for invalidation set tracking.
+            gateway_id: Gateway ID. When present, all aliases for that gateway are invalidated.
+            server_id: Optional virtual server scope for a targeted invalidation.
 
         Examples:
             >>> import asyncio
@@ -324,21 +374,83 @@ async def invalidate(self, name: str, gateway_id: Optional[str] = None) -> None:
         if not self._enabled:
             return
 
+        if gateway_id:
+            await self.invalidate_gateway(gateway_id)
+            return
+
+        cache_key = self._cache_key(name, server_id)
+
         with self._lock:
-            self._cache.pop(name, None)
+            self._cache.pop(cache_key, None)
+
+        if server_id is None:
+            await self.invalidate_all_scoped()
 
         redis = await self._get_redis_client()
         if not redis:
             return
 
         try:
-            await redis.delete(self._redis_key(name))
-            if gateway_id:
-                await redis.srem(self._gateway_set_key(gateway_id), name)
-            await redis.publish("mcpgw:cache:invalidate", f"tool_lookup:{name}")
+            await redis.delete(self._redis_key(cache_key))
+            if server_id:
+                await redis.srem(self._server_set_key(server_id), cache_key)
+            await redis.publish("mcpgw:cache:invalidate", f"tool_lookup:{cache_key}")
         except Exception as exc:
             logger.debug("ToolLookupCache Redis invalidate failed: %s", exc)
 
+    async def invalidate_all_scoped(self) -> None:
+        """Invalidate every virtual-server-scoped tool lookup."""
+        if not self._enabled:
+            return
+
+        with self._lock:
+            for cache_key in [key for key in self._cache if key.startswith("server:")]:
+                self._cache.pop(cache_key, None)
+
+        redis = await self._get_redis_client()
+        if not redis:
+            return
+
+        set_key = self._scoped_set_key()
+        try:
+            cache_keys = await redis.smembers(set_key)
+            if cache_keys:
+                keys = [self._redis_key(cache_key.decode() if isinstance(cache_key, bytes) else cache_key) for cache_key in cache_keys]
+                await redis.delete(*keys)
+            await redis.delete(set_key)
+            await redis.publish("mcpgw:cache:invalidate", "tool_lookup:scoped")
+        except Exception as exc:
+            logger.debug("ToolLookupCache Redis invalidate_all_scoped failed: %s", exc)
+
+    async def invalidate_server(self, server_id: str) -> None:
+        """Invalidate all cached tool lookups scoped to a virtual server.
+
+        Args:
+            server_id: Virtual server ID.
+        """
+        if not self._enabled:
+            return
+
+        key_prefix = self._cache_key("", server_id)
+        with self._lock:
+            for cache_key in [key for key in self._cache if key.startswith(key_prefix)]:
+                self._cache.pop(cache_key, None)
+
+        redis = await self._get_redis_client()
+        if not redis:
+            return
+
+        set_key = self._server_set_key(server_id)
+        try:
+            cache_keys = await redis.smembers(set_key)
+            if cache_keys:
+                keys = [self._redis_key(cache_key.decode() if isinstance(cache_key, bytes) else cache_key) for cache_key in cache_keys]
+                await redis.delete(*keys)
+            await redis.delete(set_key)
+            await redis.publish("mcpgw:cache:invalidate", f"tool_lookup:server:{server_id}")
+        except Exception as exc:
+            logger.debug("ToolLookupCache Redis invalidate_server failed: %s", exc)
+
     async def invalidate_gateway(self, gateway_id: str) -> None:
         """Invalidate all cached tools for a gateway.
 
diff --git a/mcpgateway/common/query_params.py b/mcpgateway/common/query_params.py
index 5d9ea695fe..73c4b7f08b 100644
--- a/mcpgateway/common/query_params.py
+++ b/mcpgateway/common/query_params.py
@@ -151,7 +151,7 @@
 QueryToolName = Annotated[
     Optional[str],
     Query(
-        max_length=255,
+        max_length=SecurityValidator.MAX_TOOL_NAME_LENGTH,
         pattern=SecurityValidator.TOOL_NAME_PATTERN,
     ),
 ]
diff --git a/mcpgateway/common/validators.py b/mcpgateway/common/validators.py
index 9245895ae4..2526b23b9a 100644
--- a/mcpgateway/common/validators.py
+++ b/mcpgateway/common/validators.py
@@ -75,7 +75,7 @@
 # precompiled at module level.
 
 # Static inline patterns used multiple times
-_HTML_SPECIAL_CHARS_RE: Pattern[str] = re.compile(r'[<>"\']')  # / removed per SEP-986
+_HTML_SPECIAL_CHARS_RE: Pattern[str] = re.compile(r'[<>"\']')
 _DANGEROUS_TEMPLATE_TAGS_RE: Pattern[str] = re.compile(r"<(script|iframe|object|embed|link|meta|base|form)\b", re.IGNORECASE)
 _EVENT_HANDLER_RE: Pattern[str] = re.compile(r"on\w+\s*=", re.IGNORECASE)
 _MIME_TYPE_RE: Pattern[str] = re.compile(r'^[a-zA-Z0-9][a-zA-Z0-9!#$&\-\^_+\.]*\/[a-zA-Z0-9][a-zA-Z0-9!#$&\-\^_+\.]*(?:\s*;\s*[a-zA-Z0-9!#$&\-\^_+\.]+=(?:[a-zA-Z0-9!#$&\-\^_+\.]+|"[^"\r\n]*"))*$')
@@ -342,7 +342,7 @@ class SecurityValidator:
     IDENTIFIER_PATTERN = settings.validation_identifier_pattern  # Default: ^[a-zA-Z0-9_\-\.]+$
     VALIDATION_SAFE_URI_PATTERN = settings.validation_safe_uri_pattern  # Default: ^[a-zA-Z0-9_\-.:/?=&%]+$
     VALIDATION_UNSAFE_URI_PATTERN = settings.validation_unsafe_uri_pattern  # Default: [<>"\'\\]
-    TOOL_NAME_PATTERN = settings.validation_tool_name_pattern  # Default: ^[a-zA-Z0-9_][a-zA-Z0-9._/-]*$ (SEP-986)
+    TOOL_NAME_PATTERN = settings.validation_tool_name_pattern  # Default: ^[a-zA-Z0-9_.-]+$ (MCP 2025-11-25)
 
     # MCP-compliant limits (configurable)
     MAX_NAME_LENGTH = settings.validation_max_name_length  # Default: 255
@@ -672,23 +672,20 @@ def validate_tool_name(cls, value: str) -> str:
             >>> try:
             ...     SecurityValidator.validate_tool_name('tool<script>')
             ... except ValueError as e:
-            ...     'must start with a letter, number, or underscore' in str(e)
+            ...     'may contain only' in str(e)
             True
             >>> try:
             ...     SecurityValidator.validate_tool_name('tool"test')
             ... except ValueError as e:
-            ...     'must start with a letter, number, or underscore' in str(e)
+            ...     'may contain only' in str(e)
             True
             >>> try:
             ...     SecurityValidator.validate_tool_name("tool'test")
             ... except ValueError as e:
-            ...     'must start with a letter, number, or underscore' in str(e)
+            ...     'may contain only' in str(e)
             True
-            >>> # Slashes are allowed per SEP-986
-            >>> SecurityValidator.validate_tool_name('tool/test')
-            'tool/test'
-            >>> SecurityValidator.validate_tool_name('namespace/subtool')
-            'namespace/subtool'
+            >>> SecurityValidator.validate_tool_name('-tool.name')
+            '-tool.name'
 
             Test length limit (line 313):
 
@@ -703,8 +700,8 @@ def validate_tool_name(cls, value: str) -> str:
             raise ValueError("Tool name cannot be empty")
 
         # MCP tools have specific naming requirements
-        if not re.match(cls.TOOL_NAME_PATTERN, value):
-            raise ValueError("Tool name must start with a letter, number, or underscore and contain only letters, numbers, periods, underscores, hyphens, and slashes")
+        if not re.fullmatch(cls.TOOL_NAME_PATTERN, value):
+            raise ValueError("Tool name may contain only letters, numbers, underscores, hyphens, and periods")
 
         # Ensure no HTML-like content (uses precompiled regex)
         if _HTML_SPECIAL_CHARS_RE.search(value):
diff --git a/mcpgateway/config.py b/mcpgateway/config.py
index 72a380f573..cfb32d940b 100644
--- a/mcpgateway/config.py
+++ b/mcpgateway/config.py
@@ -3312,7 +3312,7 @@ def validate_database(self) -> None:
     validation_identifier_pattern: str = r"^[a-zA-Z0-9_\-\.]+$"  # No spaces for IDs
     validation_safe_uri_pattern: str = r"^[a-zA-Z0-9_\-.:/?=&%{}]+$"
     validation_unsafe_uri_pattern: str = r'[<>"\'\\]'
-    validation_tool_name_pattern: str = r"^[a-zA-Z0-9_][a-zA-Z0-9._/-]*$"  # MCP tool naming per SEP-986
+    validation_tool_name_pattern: str = r"^[a-zA-Z0-9_.-]+$"  # MCP 2025-11-25 tool naming
     validation_tool_method_pattern: str = r"^[a-zA-Z][a-zA-Z0-9_\./-]*$"
     validation_cursor_pattern: str = r"^[a-zA-Z0-9_=+/-]+$"
     validation_tags_filter_pattern: str = r"^[a-zA-Z0-9_,+ .-]*$"
diff --git a/mcpgateway/main.py b/mcpgateway/main.py
index ea14b1e1de..f98f7895b6 100644
--- a/mcpgateway/main.py
+++ b/mcpgateway/main.py
@@ -11084,7 +11084,13 @@ async def _handle_tools_list_rpc(
         # Release DB connection early to prevent idle-in-transaction under load
         db.commit()
         db.close()
-        result = {"tools": serializer_func(tools)}
+        visible_tools = filter_model_visible_tools(tools)
+        serialized_tools = serializer_func(visible_tools)
+        for tool, payload in zip(visible_tools, serialized_tools, strict=True):
+            custom_name = getattr(tool, "custom_name", None)
+            if isinstance(custom_name, str) and custom_name:
+                payload["name"] = custom_name
+        result = {"tools": serialized_tools}
     else:
         tools, next_cursor = await tool_svc.list_tools(
             db,
diff --git a/mcpgateway/schemas.py b/mcpgateway/schemas.py
index 0f95223208..4f4c054484 100644
--- a/mcpgateway/schemas.py
+++ b/mcpgateway/schemas.py
@@ -1853,8 +1853,7 @@ class ToolInvocation(BaseModelWithConfigDict):
     - Arguments matching tool's input schema (validated for depth limits)
 
     Validation Rules:
-    - Tool names must start with a letter, number, or underscore and contain only
-      letters, numbers, periods, underscores, hyphens, and slashes (per SEP-986)
+    - Tool names are 1–128 characters and contain only letters, numbers, periods, underscores, or hyphens
     - Tool names cannot contain HTML special characters (<, >, ", ')
     - Arguments are validated to prevent excessively deep nesting (default max: 10 levels)
 
@@ -1901,12 +1900,17 @@ class ToolInvocation(BaseModelWithConfigDict):
         >>> tool_underscore.name
         '_5gpt_query'
 
-        >>> # Invalid: Tool name starting with hyphen
+        >>> # Valid: Tool name starting with hyphen (per MCP spec)
+        >>> tool_hyphen = ToolInvocation(name="-tool.name", arguments={})
+        >>> tool_hyphen.name
+        '-tool.name'
+
+        >>> # Invalid: Tool name with slash
         >>> try:
-        ...     ToolInvocation(name="-invalid_tool", arguments={})
+        ...     ToolInvocation(name="namespace/tool", arguments={})
         ... except ValidationError as e:
-        ...     print("Validation failed: Must start with letter, number, or underscore")
-        Validation failed: Must start with letter, number, or underscore
+        ...     print("Validation failed: Slashes not allowed")
+        Validation failed: Slashes not allowed
 
         >>> # Valid: Complex but not too deep arguments
         >>> args = {"level1": {"level2": {"level3": {"data": "value"}}}}
diff --git a/mcpgateway/services/dataplane_publisher.py b/mcpgateway/services/dataplane_publisher.py
index 096c3b95a1..4fa6b5caec 100644
--- a/mcpgateway/services/dataplane_publisher.py
+++ b/mcpgateway/services/dataplane_publisher.py
@@ -14,7 +14,7 @@
 import logging
 import os
 import socket
-from typing import Any, TypedDict
+from typing import Any, NotRequired, Sequence, TypedDict
 
 # Third-Party
 import msgpack
@@ -66,6 +66,7 @@ class BackendConfig(TypedDict):
     passthrough_headers: list[str]
     capabilities: dict[str, Any]
     allowed_tool_names: list[str]
+    tool_name_aliases: dict[str, str]
     allowed_resource_names: list[str]
     allowed_resource_uris: list[str]
     allowed_prompt_names: list[str]
@@ -83,7 +84,15 @@ class UserConfig(TypedDict):
     virtual_hosts: dict[str, VirtualHostConfig]
 
 
-BackendItems = dict[str, list[str]]
+class BackendItems(TypedDict):
+    """Names and identifiers attached to one backend."""
+
+    tools: list[str]
+    resources: list[str]
+    prompts: list[str]
+    tool_name_aliases: NotRequired[dict[str, str]]
+
+
 BackendItemsByServer = dict[str, dict[str, BackendItems]]
 
 
@@ -128,7 +137,7 @@ async def shutdown(self) -> None:
         self.task = None
         logger.info("Dataplane publisher stopped.")
 
-    async def fetch_payload(self) -> dict[str, dict[str, dict[str, Any]]] | None:
+    async def fetch_payload(self) -> dict[str, UserConfig] | None:
         """Fetch the payload to publish to Redis. Returns None on error."""
         user_data = await self.get_data_from_db()
         if user_data is None:
@@ -227,11 +236,12 @@ def create_payload(
 
             prompt_map = {prompt["id"]: prompt["name"] for prompt in prompts}
 
-            # The dataplane proxies streamable-HTTP upstreams only. Legacy
-            # HTTP+SSE gateways are excluded so the published config never
-            # advertises a backend the dataplane cannot serve.
-            gateway_base = {
-                gateway["id"]: {
+            # Backend keys are stable gateway IDs. Names and slugs are mutable
+            # presentation fields and are not globally unique. The dataplane
+            # proxies streamable-HTTP upstreams only, so legacy HTTP+SSE
+            # gateways must not be advertised as publishable backends.
+            gateway_base: dict[str, dict[str, Any]] = {
+                str(gateway["id"]): {
                     "name": gateway["name"],
                     "url": gateway["url"],
                     "transport": gateway["transport"],
@@ -259,8 +269,13 @@ def create_payload(
                         continue
 
                     backends[gateway_id] = {
-                        **gateway_config,
+                        "name": gateway_config["name"],
+                        "url": gateway_config["url"],
+                        "transport": gateway_config["transport"],
+                        "passthrough_headers": gateway_config["passthrough_headers"],
+                        "capabilities": gateway_config["capabilities"],
                         "allowed_tool_names": backend_items["tools"],
+                        "tool_name_aliases": backend_items.get("tool_name_aliases", {}),
                         "allowed_resource_names": allowed_resource_names,
                         "allowed_resource_uris": allowed_resource_uris,
                         "allowed_prompt_names": allowed_prompt_names,
@@ -320,7 +335,7 @@ async def get_data_from_db(self) -> dict[str, Any] | None:
                         DbResource.uri_template.is_(None),
                     )
                 ).all()
-                tool_rows = db.execute(select(DbTool.id, DbTool.original_name, DbTool.owner_email, DbTool.team_id, DbTool.visibility).where(DbTool.enabled.is_(True))).all()
+                tool_rows = db.execute(select(DbTool.id, DbTool.original_name, DbTool.custom_name, DbTool.owner_email, DbTool.team_id, DbTool.visibility).where(DbTool.enabled.is_(True))).all()
                 backend_items_by_server = self._get_backend_items_by_server(db)
 
                 return {
@@ -347,21 +362,21 @@ def _build_user_data(
         user_email: str,
         team_ids: set[str],
         is_admin: bool,
-        server_rows: list[Any],
-        gateway_rows: list[Any],
-        prompt_rows: list[Any],
-        resource_rows: list[Any],
-        tool_rows: list[Any],
+        server_rows: Sequence[Any],
+        gateway_rows: Sequence[Any],
+        prompt_rows: Sequence[Any],
+        resource_rows: Sequence[Any],
+        tool_rows: Sequence[Any],
         backend_items_by_server: BackendItemsByServer,
     ) -> dict[str, Any]:
         """Build already-filtered dataplane data for one user."""
-        tool_name_by_id = {tool.id: tool.original_name for tool in tool_rows if self._filter_for_user(tool, user_email, team_ids, is_admin=is_admin)}
+        tool_names_by_id = {tool.id: (tool.original_name, tool.custom_name or tool.original_name) for tool in tool_rows if self._filter_for_user(tool, user_email, team_ids, is_admin=is_admin)}
 
         return {
             "servers": [
                 {
                     "id": server.id,
-                    "backend_items": self._filter_backend_items_for_user(backend_items_by_server.get(server.id, {}), tool_name_by_id),
+                    "backend_items": self._filter_backend_items_for_user(backend_items_by_server.get(server.id, {}), tool_names_by_id),
                 }
                 for server in server_rows
                 if self._filter_for_user(server, user_email, team_ids, is_admin=is_admin)
@@ -395,16 +410,35 @@ def _filter_for_user(row: Any, user_email: str, team_ids: set[str], is_admin: bo
         return row.team_id in team_ids and visibility == "team"
 
     @staticmethod
-    def _filter_backend_items_for_user(backend_items_by_gateway: dict[str, BackendItems], tool_name_by_id: dict[str, str]) -> dict[str, BackendItems]:
+    def _filter_backend_items_for_user(backend_items_by_gateway: dict[str, BackendItems], tool_names_by_id: dict[str, tuple[str, str]]) -> dict[str, BackendItems]:
         """Filter backend tool IDs for one user and convert visible tools to names."""
-        return {
-            gateway_id: {
-                "tools": [tool_name_by_id[tool_id] for tool_id in backend_items["tools"] if tool_id in tool_name_by_id],
+        filtered: dict[str, BackendItems] = {}
+        for gateway_id, backend_items in backend_items_by_gateway.items():
+            tools: list[str] = []
+            tool_name_aliases: dict[str, str] = {}
+            for tool_id in backend_items["tools"]:
+                names = tool_names_by_id.get(tool_id)
+                if names is None:
+                    continue
+                original_name, exposed_name = names
+                tools.append(original_name)
+                if exposed_name in tool_name_aliases and tool_name_aliases[exposed_name] != original_name:
+                    logger.warning(
+                        "Duplicate exposed tool name '%s' on backend %s: keeping alias to '%s', dropping alias to '%s'",
+                        exposed_name,
+                        gateway_id,
+                        tool_name_aliases[exposed_name],
+                        original_name,
+                    )
+                    continue
+                tool_name_aliases[exposed_name] = original_name
+            filtered[gateway_id] = {
+                "tools": tools,
+                "tool_name_aliases": tool_name_aliases,
                 "resources": list(backend_items["resources"]),
                 "prompts": list(backend_items["prompts"]),
             }
-            for gateway_id, backend_items in backend_items_by_gateway.items()
-        }
+        return filtered
 
     def _get_backend_items_by_server(self, db: Any) -> BackendItemsByServer:
         """Fetch tools, resources, and prompts grouped by server and backend gateway."""
diff --git a/mcpgateway/services/server_service.py b/mcpgateway/services/server_service.py
index b7a0be6732..2dd0774c3e 100644
--- a/mcpgateway/services/server_service.py
+++ b/mcpgateway/services/server_service.py
@@ -89,6 +89,7 @@ class _AssociationType(NamedTuple):
 
 # Cache import (lazy to avoid circular dependencies)
 _REGISTRY_CACHE = None
+_TOOL_LOOKUP_CACHE = None
 
 
 def _get_registry_cache():
@@ -106,6 +107,21 @@ def _get_registry_cache():
     return _REGISTRY_CACHE
 
 
+def _get_tool_lookup_cache() -> Any:
+    """Get tool lookup cache singleton lazily.
+
+    Returns:
+        ToolLookupCache instance.
+    """
+    global _TOOL_LOOKUP_CACHE  # pylint: disable=global-statement
+    if _TOOL_LOOKUP_CACHE is None:
+        # First-Party
+        from mcpgateway.cache.tool_lookup_cache import tool_lookup_cache  # pylint: disable=import-outside-toplevel
+
+        _TOOL_LOOKUP_CACHE = tool_lookup_cache
+    return _TOOL_LOOKUP_CACHE
+
+
 def _validate_server_team_assignment(db: Session, user_email: Optional[str], target_team_id: Optional[str]) -> None:
     """Validate team assignment and ownership requirements for server updates.
 
@@ -1348,6 +1364,7 @@ async def update_server(
             # Invalidate cache after successful update
             cache = _get_registry_cache()
             await cache.invalidate_servers()
+            await _get_tool_lookup_cache().invalidate_server(str(server.id))
             # Also invalidate tags cache since server tags may have changed
             # First-Party
             from mcpgateway.cache.admin_stats_cache import admin_stats_cache  # pylint: disable=import-outside-toplevel
@@ -1656,6 +1673,7 @@ async def delete_server(self, db: Session, server_id: str, user_email: Optional[
             # Invalidate cache after successful deletion
             cache = _get_registry_cache()
             await cache.invalidate_servers()
+            await _get_tool_lookup_cache().invalidate_server(str(server_info["id"]))
             # Also invalidate tags cache since server tags may have changed
             # First-Party
             from mcpgateway.cache.admin_stats_cache import admin_stats_cache  # pylint: disable=import-outside-toplevel
diff --git a/mcpgateway/services/tool_service.py b/mcpgateway/services/tool_service.py
index b24727b818..f170c32494 100644
--- a/mcpgateway/services/tool_service.py
+++ b/mcpgateway/services/tool_service.py
@@ -17,6 +17,7 @@
 import asyncio
 import base64
 import binascii
+from collections import Counter
 from collections.abc import Mapping
 from datetime import datetime, timezone
 from functools import lru_cache
@@ -140,7 +141,7 @@ def _get_registry_cache():
 _downstream_session_id_from_request = downstream_session_id_from_request_context
 
 
-def _get_tool_lookup_cache():
+def _get_tool_lookup_cache() -> Any:
     """Get tool lookup cache singleton lazily.
 
     Returns:
@@ -155,6 +156,19 @@ def _get_tool_lookup_cache():
     return _TOOL_LOOKUP_CACHE
 
 
+def _tool_name_match_priority(tool: Any, requested_name: str) -> int:
+    """Return the lookup priority for exact stored or custom tool-name matches.
+
+    Args:
+        tool: Candidate tool record.
+        requested_name: Name supplied by the caller.
+
+    Returns:
+        Zero for an exact stored-name or custom-name match; one for fallback matches.
+    """
+    return 0 if requested_name in (getattr(tool, "name", None), getattr(tool, "custom_name", None)) else 1
+
+
 # Initialize logging service first
 logging_service = LoggingService()
 logger = logging_service.get_logger(__name__)
@@ -162,6 +176,21 @@ def _get_tool_lookup_cache():
 _W3C_TRACEPARENT_RE = re.compile(r"^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$")
 
 
+def _warn_on_duplicate_exposed_tool_names(server_id: str, exposed_names: List[str]) -> None:
+    """Warn when a virtual server exposes the same tool name more than once.
+
+    MCP tool names SHOULD be unique within a server; duplicate exposed names
+    cannot be disambiguated by clients and make scoped invocation ambiguous.
+
+    Args:
+        server_id: Virtual server whose listing is being produced.
+        exposed_names: Protocol-visible tool names in the listing.
+    """
+    duplicates = sorted({name for name, count in Counter(exposed_names).items() if count > 1})
+    if duplicates:
+        logger.warning("Virtual server %s exposes duplicate tool names %s; rename the tools' custom names to keep invocation unambiguous", server_id, duplicates)
+
+
 def _extract_tenant_id_from_payload(team_id: Any) -> Optional[str]:
     """Extract a valid tenant id from a raw tool payload team_id value.
 
@@ -3017,6 +3046,7 @@ async def list_server_tools(
                     logger.exception("Failed to convert tool %s (%s): %s", getattr(tool, "id", "unknown"), getattr(tool, "name", "unknown"), e)
                     # Continue with remaining tools instead of failing completely
 
+            _warn_on_duplicate_exposed_tool_names(server_id, [tool_read.custom_name for tool_read in result if getattr(tool_read, "custom_name", None)])
             return result
 
     async def list_server_mcp_tool_definitions(
@@ -3055,7 +3085,7 @@ async def list_server_mcp_tool_definitions(
                 "mcp.definition_mode": True,
             },
         ):
-            name_column = DbTool.__table__.c.name
+            name_column = DbTool.__table__.c.custom_name
             query = (
                 select(
                     name_column.label("name"),
@@ -3109,6 +3139,7 @@ async def list_server_mcp_tool_definitions(
                     payload["outputSchema"] = row["output_schema"]
                 result.append(payload)
 
+            _warn_on_duplicate_exposed_tool_names(server_id, [definition["name"] for definition in result])
             return result
 
     async def list_tools_for_user(
@@ -4133,6 +4164,7 @@ async def prepare_rust_mcp_tool_execution(
         is_direct_proxy = False
         tool = None
         gateway = None
+        tool_lookup_cache = _get_tool_lookup_cache()
         tool_selected_from_server_scope = False
         tool_payload: Dict[str, Any] = {}
         gateway_payload: Optional[Dict[str, Any]] = None
@@ -4167,10 +4199,10 @@ async def prepare_rust_mcp_tool_execution(
                 }
 
         if not is_direct_proxy:
-            tool_lookup_cache = _get_tool_lookup_cache()
-            cached_payload = await tool_lookup_cache.get(name) if tool_lookup_cache.enabled else None
+            cached_payload = await tool_lookup_cache.get(name, server_id=server_id) if tool_lookup_cache.enabled else None
 
             if cached_payload:
+                tool_selected_from_server_scope = bool(server_id)
                 status = cached_payload.get("status", "active")
                 if status == "missing":
                     raise ToolNotFoundError(f"Tool not found: {name}")
@@ -4197,7 +4229,7 @@ async def prepare_rust_mcp_tool_execution(
                 for candidate in tools:
                     tool_dict = {"visibility": candidate.visibility, "team_id": candidate.team_id, "owner_email": candidate.owner_email}
                     if await self._check_tool_access(db, tool_dict, user_email, token_teams):
-                        name_priority = 0 if getattr(candidate, "name", None) == name else 1
+                        name_priority = _tool_name_match_priority(candidate, name)
                         priority = visibility_priority.get(candidate.visibility, 99)
                         accessible_tools.append((name_priority, priority, candidate))
 
@@ -4215,7 +4247,8 @@ async def prepare_rust_mcp_tool_execution(
                 raise ToolNotFoundError(f"Tool '{name}' exists but is inactive")
 
             if not tool.reachable:
-                await tool_lookup_cache.set_negative(name, "offline")
+                if server_id is None:
+                    await tool_lookup_cache.set_negative(name, "offline")
                 raise ToolNotFoundError(f"Tool '{name}' exists but is currently offline. Please verify if it is running.")
 
             gateway = tool.gateway
@@ -4223,7 +4256,11 @@ async def prepare_rust_mcp_tool_execution(
             tool_payload = cache_payload.get("tool") or {}
             gateway_payload = cache_payload.get("gateway")
             if not multiple_found:
-                await tool_lookup_cache.set(name, cache_payload, gateway_id=tool_payload.get("gateway_id"))
+                gateway_id = tool_payload.get("gateway_id")
+                if server_id:
+                    await tool_lookup_cache.set(name, cache_payload, gateway_id=gateway_id, server_id=server_id)
+                elif server_id is None:
+                    await tool_lookup_cache.set(name, cache_payload, gateway_id=gateway_id)
 
         if tool_payload.get("enabled") is False:
             raise ToolNotFoundError(f"Tool '{name}' exists but is inactive")
@@ -4239,18 +4276,19 @@ async def prepare_rust_mcp_tool_execution(
         if require_model_visible and not is_model_visible_tool(tool_payload):
             raise ToolNotFoundError(f"Tool not found: {name}")
 
-        if server_id and not tool_selected_from_server_scope:
+        if server_id:
             tool_id_for_check = tool_payload.get("id")
             if not tool_id_for_check:
                 raise ToolNotFoundError(f"Tool not found: {name}")
-            server_match = db.execute(
-                select(server_tool_association.c.tool_id).where(
-                    server_tool_association.c.server_id == server_id,
-                    server_tool_association.c.tool_id == tool_id_for_check,
-                )
-            ).first()
-            if not server_match:
-                raise ToolNotFoundError(f"Tool not found: {name}")
+            if not tool_selected_from_server_scope:
+                server_match = db.execute(
+                    select(server_tool_association.c.tool_id).where(
+                        server_tool_association.c.server_id == server_id,
+                        server_tool_association.c.tool_id == tool_id_for_check,
+                    )
+                ).first()
+                if not server_match:
+                    raise ToolNotFoundError(f"Tool not found: {name}")
 
         tool_integration_type = tool_payload.get("integration_type")
         if tool_integration_type != "MCP":
@@ -4629,12 +4667,16 @@ def _load_invocable_tools(self, db: Session, name: str, server_id: Optional[str]
         Returns:
             A list of candidate tool ORM rows matching the request.
         """
-        name_filter = DbTool.name == name  # pylint: disable=comparison-with-callable
-        if server_id:
-            name_filter = or_(name_filter, DbTool.original_name == name)
-        query = select(DbTool).options(joinedload(DbTool.gateway)).where(name_filter)
         if server_id:
-            query = query.join(server_tool_association, DbTool.id == server_tool_association.c.tool_id).where(server_tool_association.c.server_id == server_id)
+            name_filter = or_(DbTool.custom_name == name, DbTool.name == name, DbTool.original_name == name)  # pylint: disable=comparison-with-callable
+            query = (
+                select(DbTool)
+                .options(joinedload(DbTool.gateway))
+                .join(server_tool_association, DbTool.id == server_tool_association.c.tool_id)
+                .where(name_filter, server_tool_association.c.server_id == server_id)
+            )
+        else:
+            query = select(DbTool).options(joinedload(DbTool.gateway)).where(DbTool.name == name)  # pylint: disable=comparison-with-callable
         return db.execute(query).scalars().all()
 
     # ------------------------------------------------------------------
@@ -4840,6 +4882,8 @@ async def invoke_tool(
         is_direct_proxy = False
         tool = None
         gateway = None
+        tool_lookup_cache = _get_tool_lookup_cache()
+        tool_selected_from_server_scope = False
         tool_payload: Dict[str, Any] = {}
         gateway_payload: Optional[Dict[str, Any]] = None
 
@@ -4889,10 +4933,10 @@ async def invoke_tool(
 
         # Normal mode: look up tool in database/cache
         if not is_direct_proxy:
-            tool_lookup_cache = _get_tool_lookup_cache()
-            cached_payload = await tool_lookup_cache.get(name) if tool_lookup_cache.enabled else None
+            cached_payload = await tool_lookup_cache.get(name, server_id=server_id) if tool_lookup_cache.enabled else None
 
             if cached_payload:
+                tool_selected_from_server_scope = bool(server_id)
                 status = cached_payload.get("status", "active")
                 if status == "missing":
                     raise ToolNotFoundError(f"Tool not found: {name}")
@@ -4909,6 +4953,7 @@ async def invoke_tool(
             # Use scalars().all() instead of scalar_one_or_none() to handle duplicate
             # tool names across teams without crashing on MultipleResultsFound.
             tools = self._load_invocable_tools(db, name, server_id=server_id)
+            tool_selected_from_server_scope = bool(server_id)
 
             if not tools:
                 raise ToolNotFoundError(f"Tool not found: {name}")
@@ -4925,7 +4970,7 @@ async def invoke_tool(
                 for t in tools:
                     tool_dict = {"visibility": t.visibility, "team_id": t.team_id, "owner_email": t.owner_email}
                     if await self._check_tool_access(db, tool_dict, user_email, token_teams):
-                        name_priority = 0 if getattr(t, "name", None) == name else 1
+                        name_priority = _tool_name_match_priority(t, name)
                         priority = visibility_priority.get(t.visibility, 99)
                         accessible_tools.append((name_priority, priority, t))
 
@@ -4947,7 +4992,8 @@ async def invoke_tool(
                 raise ToolNotFoundError(f"Tool '{name}' exists but is inactive")
 
             if not tool.reachable:
-                await tool_lookup_cache.set_negative(name, "offline")
+                if server_id is None:
+                    await tool_lookup_cache.set_negative(name, "offline")
                 raise ToolNotFoundError(f"Tool '{name}' exists but is currently offline. Please verify if it is running.")
 
             gateway = tool.gateway
@@ -4957,7 +5003,11 @@ async def invoke_tool(
             # Skip caching when multiple tools share a name — resolution is
             # user-dependent, so a cached result could be wrong for other users.
             if not multiple_found:
-                await tool_lookup_cache.set(name, cache_payload, gateway_id=tool_payload.get("gateway_id"))
+                gateway_id = tool_payload.get("gateway_id")
+                if server_id:
+                    await tool_lookup_cache.set(name, cache_payload, gateway_id=gateway_id, server_id=server_id)
+                elif server_id is None:
+                    await tool_lookup_cache.set(name, cache_payload, gateway_id=gateway_id)
 
         if tool_payload.get("enabled") is False:
             raise ToolNotFoundError(f"Tool '{name}' exists but is inactive")
@@ -4976,7 +5026,8 @@ async def invoke_tool(
             # Check deprecated status after RBAC to avoid leaking tool existence
             if tool_payload.get("deprecated") is True:
                 # Cache the deprecated status to avoid repeated DB queries
-                await tool_lookup_cache.set_negative(name, "deprecated")
+                if server_id is None:
+                    await tool_lookup_cache.set_negative(name, "deprecated")
                 raise ToolInvocationError(f"Tool '{name}' is deprecated and cannot be executed. Please update your agent to use an alternative tool.")
 
             # ═══════════════════════════════════════════════════════════════════════════
@@ -4991,14 +5042,15 @@ async def invoke_tool(
                     logger.warning("Tool '%s' has no ID in payload, cannot verify server membership", name)
                     raise ToolNotFoundError(f"Tool not found: {name}")
 
-                server_match = db.execute(
-                    select(server_tool_association.c.tool_id).where(
-                        server_tool_association.c.server_id == server_id,
-                        server_tool_association.c.tool_id == tool_id_for_check,
-                    )
-                ).first()
-                if not server_match:
-                    raise ToolNotFoundError(f"Tool not found: {name}")
+                if not tool_selected_from_server_scope:
+                    server_match = db.execute(
+                        select(server_tool_association.c.tool_id).where(
+                            server_tool_association.c.server_id == server_id,
+                            server_tool_association.c.tool_id == tool_id_for_check,
+                        )
+                    ).first()
+                    if not server_match:
+                        raise ToolNotFoundError(f"Tool not found: {name}")
 
         if require_app_visible:
             if is_direct_proxy or not is_app_visible_tool(tool_payload):
diff --git a/mcpgateway/transports/streamablehttp_transport.py b/mcpgateway/transports/streamablehttp_transport.py
index 3d6a226985..049211145a 100644
--- a/mcpgateway/transports/streamablehttp_transport.py
+++ b/mcpgateway/transports/streamablehttp_transport.py
@@ -2360,7 +2360,7 @@ async def list_tools() -> List[types.Tool]:
 
                 # Default cache mode: use database
                 tools = await tool_service.list_server_tools(db, server_id, user_email=user_email, token_teams=token_teams, _request_headers=request_headers)
-                return _tools_for_client(tools)
+                return [_to_mcp_tool(tool, name=_safe_str_attr(tool, "custom_name") or tool.name) for tool in filter_model_visible_tools(tools)]
         except Exception as e:
             logger.error("Error listing tools:%s", e)
             return []
diff --git a/mcpgateway/utils/error_formatter.py b/mcpgateway/utils/error_formatter.py
index 13dbc20839..bcb095141e 100644
--- a/mcpgateway/utils/error_formatter.py
+++ b/mcpgateway/utils/error_formatter.py
@@ -103,15 +103,15 @@ def _get_user_message(field: str, technical_msg: str) -> str:
             str: User-friendly error message with field context
 
         Examples:
-            >>> # Test letter requirement mapping
-            >>> msg = ErrorFormatter._get_user_message("name", "Tool name must start with a letter, number, or underscore")
+            >>> # Test tool-name character mapping
+            >>> msg = ErrorFormatter._get_user_message("name", "Tool name may contain only letters")
             >>> msg
-            'Name must start with a letter, number, or underscore and contain only letters, numbers, periods, underscores, hyphens, and slashes'
+            'Name may contain only letters, numbers, periods, underscores, and hyphens'
 
             >>> # Test length validation mapping
-            >>> msg = ErrorFormatter._get_user_message("description", "Tool name exceeds maximum length")
+            >>> msg = ErrorFormatter._get_user_message("description", "Tool name exceeds MCP spec limit of 128 characters (got 129)")
             >>> msg
-            'Description is too long (maximum 255 characters)'
+            'Description is too long (maximum 128 characters)'
 
             >>> # Test URL validation mapping
             >>> msg = ErrorFormatter._get_user_message("endpoint", "Tool URL must start with http")
@@ -134,8 +134,8 @@ def _get_user_message(field: str, technical_msg: str) -> str:
             'Invalid custom_field'
         """
         mappings = {
-            "Tool name must start with a letter, number, or underscore": f"{field.title()} must start with a letter, number, or underscore and contain only letters, numbers, periods, underscores, hyphens, and slashes",
-            "Tool name exceeds maximum length": f"{field.title()} is too long (maximum 255 characters)",
+            "Tool name may contain only": f"{field.title()} may contain only letters, numbers, periods, underscores, and hyphens",
+            "Tool name exceeds MCP spec limit": f"{field.title()} is too long (maximum 128 characters)",
             "Tool URL must start with": f"{field.title()} must be a valid HTTP or WebSocket URL",
             "cannot contain directory traversal": f"{field.title()} contains invalid characters",
             "contains HTML tags": f"{field.title()} cannot contain HTML or script tags",
diff --git a/tests/e2e/test_main_apis.py b/tests/e2e/test_main_apis.py
index 776cb404b9..afcccd804d 100644
--- a/tests/e2e/test_main_apis.py
+++ b/tests/e2e/test_main_apis.py
@@ -838,7 +838,7 @@ async def test_create_tool_validation_errors(self, client: AsyncClient, mock_aut
         # Tool names with hyphens are valid per MCP spec
         if response.status_code == 422:
             # May fail for other reasons (duplicate, etc)
-            assert "must start with a letter, number, or underscore" in str(response.json()) or "already exists" in str(response.json())
+            assert "may contain only" in str(response.json()) or "already exists" in str(response.json())
         else:
             assert response.status_code == 200
 
diff --git a/tests/security/test_input_validation.py b/tests/security/test_input_validation.py
index e0f24743ac..cf1759266d 100644
--- a/tests/security/test_input_validation.py
+++ b/tests/security/test_input_validation.py
@@ -352,8 +352,10 @@ def must_fail(value: str, label: str = "Invalid name") -> None:
         valid_names = [
             "valid_tool",
             "tool123",
-            "my_tool",  # hyphens not allowed
-            "tool_name",  # dots not allowed
+            "my-tool",
+            "tool.name",
+            "-tool",
+            ".tool",
             "ToolName",
             "a" * 50,  # at length limit
         ]
@@ -382,19 +384,16 @@ def must_fail(value: str, label: str = "Invalid name") -> None:
             "tool[name]",
             "tool|name",
             "tool\\name",
-            # "tool/name",      # slash allowed per SEP-986
+            "tool/name",
             "tool<name>",
             "tool>name>",
             "tool?name",
             "tool!name",
-            # "tool-name",      # hyphen
-            # "tool.name",      # dot
             "",  # empty
             " ",  # just space
             "\n",  # newline
             "\t",  # tab
             "a" * 256,  # too long
-            "-tool",  # must start with letter, number, or underscore (hyphen not allowed)
         ]
         for name in invalid_names:
             logger.debug("Testing invalid tool name: %r", name)
diff --git a/tests/security/test_query_param_validation.py b/tests/security/test_query_param_validation.py
index 36ef2ca05d..ba7ee73224 100644
--- a/tests/security/test_query_param_validation.py
+++ b/tests/security/test_query_param_validation.py
@@ -224,7 +224,7 @@ def test_sso_error_pattern(error: str, expected: bool) -> None:
 
 
 # ---------------------------------------------------------------------------
-# MCP tool name - SEP-986 compliance.
+# MCP tool-name compliance.
 # ---------------------------------------------------------------------------
 
 
@@ -237,7 +237,7 @@ def test_sso_error_pattern(error: str, expected: bool) -> None:
         ("tool_1", True),
         ("_5gpt_query", True),
         ("my.namespace.tool", True),
-        ("namespace/subtool", True),
+        ("namespace/subtool", False),
         ("1tool", True),
         ("", False),
         ("tool<script>", False),
@@ -245,12 +245,12 @@ def test_sso_error_pattern(error: str, expected: bool) -> None:
         ("tool'test", False),
         ("tool test", False),
         ("tool:sub", False),
-        (".hidden", False),
-        ("-leading-hyphen", False),
+        (".hidden", True),
+        ("-leading-hyphen", True),
     ],
 )
 def test_mcp_tool_name_pattern(tool_name: str, expected: bool) -> None:
-    """Filter-side tool_name mirrors MCP SEP-986 (config.validation_tool_name_pattern)."""
+    """Filter-side tool_name mirrors config.validation_tool_name_pattern."""
     assert _matches(MCP_TOOL_NAME, tool_name) is expected
 
 
diff --git a/tests/unit/mcpgateway/cache/test_cache_invalidation_subscriber.py b/tests/unit/mcpgateway/cache/test_cache_invalidation_subscriber.py
index ed05ebff27..90a9bc22c6 100644
--- a/tests/unit/mcpgateway/cache/test_cache_invalidation_subscriber.py
+++ b/tests/unit/mcpgateway/cache/test_cache_invalidation_subscriber.py
@@ -149,6 +149,43 @@ async def test_process_tool_lookup_gateway_invalidation(self, cache_subscriber):
                 assert "tool-a" not in mock_tool_lookup._cache
                 assert "tool-b" in mock_tool_lookup._cache
 
+    @pytest.mark.asyncio
+    async def test_process_tool_lookup_server_invalidation(self, cache_subscriber):
+        """Test processing of tool_lookup:server:id invalidation message."""
+        mock_tool_lookup = MagicMock()
+        mock_tool_lookup._cache_key = lambda name, server_id=None: f"server:{server_id}:{name}" if server_id else name
+        mock_tool_lookup._cache = {
+            "tool-a": MagicMock(value={"status": "active"}),
+            "server:srv-123:tool-a": MagicMock(value={"status": "active"}),
+            "server:srv-456:tool-a": MagicMock(value={"status": "active"}),
+        }
+        mock_tool_lookup._lock = threading.Lock()
+
+        with patch.dict("sys.modules", {"mcpgateway.cache.tool_lookup_cache": MagicMock(tool_lookup_cache=mock_tool_lookup)}):
+            await cache_subscriber._process_invalidation("tool_lookup:server:srv-123")
+
+        assert "tool-a" in mock_tool_lookup._cache
+        assert "server:srv-123:tool-a" not in mock_tool_lookup._cache
+        assert "server:srv-456:tool-a" in mock_tool_lookup._cache
+
+    @pytest.mark.asyncio
+    async def test_process_all_scoped_tool_lookup_invalidation(self, cache_subscriber):
+        """Test processing of the all-scoped tool lookup invalidation message."""
+        mock_tool_lookup = MagicMock()
+        mock_tool_lookup._cache = {
+            "tool-a": MagicMock(value={"status": "active"}),
+            "server:srv-123:tool-a": MagicMock(value={"status": "active"}),
+            "server:srv-456:tool-a": MagicMock(value={"status": "active"}),
+        }
+        mock_tool_lookup._lock = threading.Lock()
+
+        with patch.dict("sys.modules", {"mcpgateway.cache.tool_lookup_cache": MagicMock(tool_lookup_cache=mock_tool_lookup)}):
+            await cache_subscriber._process_invalidation("tool_lookup:scoped")
+
+        assert "tool-a" in mock_tool_lookup._cache
+        assert "server:srv-123:tool-a" not in mock_tool_lookup._cache
+        assert "server:srv-456:tool-a" not in mock_tool_lookup._cache
+
     @pytest.mark.asyncio
     async def test_process_admin_invalidation(self, cache_subscriber):
         """Test processing of admin:prefix invalidation message."""
@@ -567,6 +604,8 @@ async def test_invalidation_message_parsing(self):
             await subscriber._process_invalidation("registry:agents")
             await subscriber._process_invalidation("tool_lookup:my-tool")
             await subscriber._process_invalidation("tool_lookup:gateway:gw-123")
+            await subscriber._process_invalidation("tool_lookup:server:srv-123")
+            await subscriber._process_invalidation("tool_lookup:scoped")
             await subscriber._process_invalidation("admin:users")
             await subscriber._process_invalidation("admin:teams")
             # Unknown formats should be handled gracefully
diff --git a/tests/unit/mcpgateway/cache/test_tool_lookup_cache.py b/tests/unit/mcpgateway/cache/test_tool_lookup_cache.py
index 6e2a94f3c7..2a9ff0cdc9 100644
--- a/tests/unit/mcpgateway/cache/test_tool_lookup_cache.py
+++ b/tests/unit/mcpgateway/cache/test_tool_lookup_cache.py
@@ -9,7 +9,7 @@
 # Standard
 import builtins
 import time
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, call, MagicMock
 
 # Third-Party
 import orjson
@@ -40,6 +40,51 @@ async def test_tool_lookup_cache_set_get_l1(tool_lookup_cache_instance):
     assert stats["l1_hit_count"] == 1
 
 
+@pytest.mark.asyncio
+async def test_tool_lookup_cache_isolates_server_scopes(tool_lookup_cache_instance):
+    global_payload = {"status": "active", "tool": {"name": "global-tool"}}
+    server_one_payload = {"status": "active", "tool": {"name": "server-one-tool"}}
+    server_two_payload = {"status": "active", "tool": {"name": "server-two-tool"}}
+
+    await tool_lookup_cache_instance.set("shared-name", global_payload)
+    await tool_lookup_cache_instance.set("shared-name", server_one_payload, gateway_id="gw-1", server_id="srv-1")
+    await tool_lookup_cache_instance.set("shared-name", server_two_payload, gateway_id="gw-2", server_id="srv-2")
+
+    assert await tool_lookup_cache_instance.get("shared-name") == global_payload
+    assert await tool_lookup_cache_instance.get("shared-name", server_id="srv-1") == server_one_payload
+    assert await tool_lookup_cache_instance.get("shared-name", server_id="srv-2") == server_two_payload
+
+
+@pytest.mark.asyncio
+async def test_tool_lookup_cache_invalidate_server(tool_lookup_cache_instance):
+    global_payload = {"status": "active", "tool": {"name": "global-tool"}}
+    server_one_payload = {"status": "active", "tool": {"name": "server-one-tool"}}
+    server_two_payload = {"status": "active", "tool": {"name": "server-two-tool"}}
+
+    await tool_lookup_cache_instance.set("shared-name", global_payload)
+    await tool_lookup_cache_instance.set("shared-name", server_one_payload, gateway_id="gw-1", server_id="srv-1")
+    await tool_lookup_cache_instance.set("shared-name", server_two_payload, gateway_id="gw-2", server_id="srv-2")
+
+    await tool_lookup_cache_instance.invalidate_server("srv-1")
+
+    assert await tool_lookup_cache_instance.get("shared-name") == global_payload
+    assert await tool_lookup_cache_instance.get("shared-name", server_id="srv-1") is None
+    assert await tool_lookup_cache_instance.get("shared-name", server_id="srv-2") == server_two_payload
+
+
+@pytest.mark.asyncio
+async def test_tool_lookup_cache_local_tool_invalidation_clears_scoped_entries(tool_lookup_cache_instance):
+    scoped_payload = {"status": "active", "tool": {"id": "local-tool", "name": "local-tool", "gateway_id": None}}
+
+    await tool_lookup_cache_instance.set("local-tool", scoped_payload, server_id="srv-1")
+    await tool_lookup_cache_instance.set("local-alias", scoped_payload, server_id="srv-2")
+
+    await tool_lookup_cache_instance.invalidate("local-tool")
+
+    assert await tool_lookup_cache_instance.get("local-tool", server_id="srv-1") is None
+    assert await tool_lookup_cache_instance.get("local-alias", server_id="srv-2") is None
+
+
 @pytest.mark.asyncio
 async def test_tool_lookup_cache_lru_eviction(tool_lookup_cache_instance):
     tool_lookup_cache_instance._l1_maxsize = 1
@@ -116,7 +161,7 @@ async def test_tool_lookup_cache_l2_hit(tool_lookup_cache_instance):
 
 
 @pytest.mark.asyncio
-async def test_tool_lookup_cache_set_with_gateway_updates_redis(tool_lookup_cache_instance):
+async def test_tool_lookup_cache_set_with_gateway_and_server_updates_redis(tool_lookup_cache_instance):
     tool_lookup_cache_instance._l2_enabled = True
     payload = {"status": "active", "tool": {"name": "tool-a"}}
 
@@ -126,10 +171,15 @@ async def test_tool_lookup_cache_set_with_gateway_updates_redis(tool_lookup_cach
     redis.expire = AsyncMock()
     tool_lookup_cache_instance._get_redis_client = AsyncMock(return_value=redis)
 
-    await tool_lookup_cache_instance.set("tool-a", payload, gateway_id="gw-1")
-    assert redis.setex.called
-    assert redis.sadd.called
-    assert redis.expire.called
+    await tool_lookup_cache_instance.set("tool-a", payload, gateway_id="gw-1", server_id="srv-1")
+
+    redis.setex.assert_awaited_once_with("mcpgw:tool_lookup:server:srv-1:tool-a", tool_lookup_cache_instance._ttl_seconds, orjson.dumps(payload))
+    assert redis.sadd.await_args_list == [
+        call("mcpgw:tool_lookup:gateway:gw-1", "server:srv-1:tool-a"),
+        call("mcpgw:tool_lookup:server:srv-1", "server:srv-1:tool-a"),
+        call("mcpgw:tool_lookup_index:scoped", "server:srv-1:tool-a"),
+    ]
+    assert redis.expire.await_count == 3
 
 
 @pytest.mark.asyncio
@@ -147,14 +197,13 @@ async def test_tool_lookup_cache_set_redis_exception_is_swallowed(tool_lookup_ca
 async def test_tool_lookup_cache_invalidate_redis(tool_lookup_cache_instance):
     tool_lookup_cache_instance._l2_enabled = True
     redis = MagicMock()
+    redis.smembers = AsyncMock(return_value={b"tool-a", b"server:srv-1:tool-a"})
     redis.delete = AsyncMock()
-    redis.srem = AsyncMock()
     redis.publish = AsyncMock()
     tool_lookup_cache_instance._get_redis_client = AsyncMock(return_value=redis)
 
     await tool_lookup_cache_instance.invalidate("tool-a", gateway_id="gw-1")
     assert redis.delete.called
-    assert redis.srem.called
     assert redis.publish.called
 
 
@@ -162,7 +211,7 @@ async def test_tool_lookup_cache_invalidate_redis(tool_lookup_cache_instance):
 async def test_tool_lookup_cache_invalidate_redis_exception_is_swallowed(tool_lookup_cache_instance):
     tool_lookup_cache_instance._l2_enabled = True
     redis = MagicMock()
-    redis.delete = AsyncMock(side_effect=RuntimeError("boom"))
+    redis.smembers = AsyncMock(side_effect=RuntimeError("boom"))
     tool_lookup_cache_instance._get_redis_client = AsyncMock(return_value=redis)
 
     # Exception path is intentionally swallowed and logged.
@@ -183,6 +232,38 @@ async def test_tool_lookup_cache_invalidate_gateway_redis(tool_lookup_cache_inst
     assert redis.publish.called
 
 
+@pytest.mark.asyncio
+async def test_tool_lookup_cache_invalidate_server_redis(tool_lookup_cache_instance):
+    tool_lookup_cache_instance._l2_enabled = True
+    redis = MagicMock()
+    redis.smembers = AsyncMock(return_value={b"server:srv-1:tool-a", "server:srv-1:tool-b"})
+    redis.delete = AsyncMock()
+    redis.publish = AsyncMock()
+    tool_lookup_cache_instance._get_redis_client = AsyncMock(return_value=redis)
+
+    await tool_lookup_cache_instance.invalidate_server("srv-1")
+
+    redis.smembers.assert_awaited_once_with("mcpgw:tool_lookup:server:srv-1")
+    assert redis.delete.await_count == 2
+    redis.publish.assert_awaited_once_with("mcpgw:cache:invalidate", "tool_lookup:server:srv-1")
+
+
+@pytest.mark.asyncio
+async def test_tool_lookup_cache_invalidate_all_scoped_redis(tool_lookup_cache_instance):
+    tool_lookup_cache_instance._l2_enabled = True
+    redis = MagicMock()
+    redis.smembers = AsyncMock(return_value={b"server:srv-1:tool-a", "server:srv-2:tool-b"})
+    redis.delete = AsyncMock()
+    redis.publish = AsyncMock()
+    tool_lookup_cache_instance._get_redis_client = AsyncMock(return_value=redis)
+
+    await tool_lookup_cache_instance.invalidate_all_scoped()
+
+    redis.smembers.assert_awaited_once_with("mcpgw:tool_lookup_index:scoped")
+    assert redis.delete.await_count == 2
+    redis.publish.assert_awaited_once_with("mcpgw:cache:invalidate", "tool_lookup:scoped")
+
+
 def test_tool_lookup_cache_import_error_defaults(monkeypatch):
     real_import = builtins.__import__
 
@@ -264,6 +345,8 @@ async def test_tool_lookup_cache_disabled_noops():
     await cache.set("tool-x", {"status": "inactive"})
     await cache.invalidate("tool-x")
     await cache.invalidate_gateway("gw-1")
+    await cache.invalidate_server("srv-1")
+    await cache.invalidate_all_scoped()
     assert len(cache._cache) == 0
 
 
@@ -284,3 +367,13 @@ async def test_tool_lookup_cache_invalidate_gateway_redis_error(tool_lookup_cach
     tool_lookup_cache_instance._get_redis_client = AsyncMock(return_value=redis)
 
     await tool_lookup_cache_instance.invalidate_gateway("gw-1")
+
+
+@pytest.mark.asyncio
+async def test_tool_lookup_cache_invalidate_server_redis_error(tool_lookup_cache_instance):
+    tool_lookup_cache_instance._l2_enabled = True
+    redis = MagicMock()
+    redis.smembers = AsyncMock(side_effect=RuntimeError("boom"))
+    tool_lookup_cache_instance._get_redis_client = AsyncMock(return_value=redis)
+
+    await tool_lookup_cache_instance.invalidate_server("srv-1")
diff --git a/tests/unit/mcpgateway/services/test_authorization_access.py b/tests/unit/mcpgateway/services/test_authorization_access.py
index ebb199f247..bdb0de513e 100644
--- a/tests/unit/mcpgateway/services/test_authorization_access.py
+++ b/tests/unit/mcpgateway/services/test_authorization_access.py
@@ -646,14 +646,10 @@ def mock_fresh_session():
     @pytest.mark.asyncio
     async def test_invoke_tool_requires_server_membership(self, tool_service, mock_db):
         """Tool must be attached to server when server_id is provided."""
-        mock_tool = create_mock_tool(visibility="public")
-
         mock_scalar = Mock()
-        mock_scalar.scalar_one_or_none.return_value = mock_tool
         mock_scalar.scalars.return_value = mock_scalar
-        mock_scalar.all.return_value = [mock_tool]
-        # First call returns tool, second call (server membership check) returns None
-        mock_db.execute = Mock(side_effect=[mock_scalar, MagicMock(first=Mock(return_value=None))])
+        mock_scalar.all.return_value = []
+        mock_db.execute = Mock(return_value=mock_scalar)
 
         with pytest.raises(ToolNotFoundError) as exc_info:
             await tool_service.invoke_tool(
@@ -669,7 +665,7 @@ async def test_invoke_tool_requires_server_membership(self, tool_service, mock_d
 
     @pytest.mark.asyncio
     async def test_invoke_tool_denies_when_tool_id_missing(self, tool_service, mock_db):
-        """Should deny access when tool has no ID (can't verify server membership)."""
+        """Should deny access when a server-scoped tool has no ID."""
         mock_tool = create_mock_tool(visibility="public")
         mock_tool.id = None  # No ID - will fail server membership check
 
diff --git a/tests/unit/mcpgateway/services/test_dataplane_publisher.py b/tests/unit/mcpgateway/services/test_dataplane_publisher.py
index 96e67292cb..83c853a8f3 100644
--- a/tests/unit/mcpgateway/services/test_dataplane_publisher.py
+++ b/tests/unit/mcpgateway/services/test_dataplane_publisher.py
@@ -7,6 +7,7 @@
 """
 
 import asyncio
+import logging
 from unittest.mock import ANY, AsyncMock, MagicMock, patch
 
 import pytest
@@ -207,6 +208,7 @@ async def test_full_payload_generation_with_mock_db():
     tool1.id = "t1"
     tool1.name = "gw1-public_tool"
     tool1.original_name = "public_tool"
+    tool1.custom_name = "Public.Tool"
     tool1.owner_email = "user1@example.com"
     tool1.team_id = "team1"
     tool1.visibility = "public"
@@ -216,6 +218,7 @@ async def test_full_payload_generation_with_mock_db():
     tool2.id = "t2"
     tool2.name = "gw1-private_tool"
     tool2.original_name = "private_tool"
+    tool2.custom_name = "Private-Tool"
     tool2.owner_email = "user1@example.com"
     tool2.team_id = "team1"
     tool2.visibility = "private"
@@ -225,6 +228,7 @@ async def test_full_payload_generation_with_mock_db():
     tool3.id = "t3"
     tool3.name = "gw1-team2_tool"
     tool3.original_name = "team2_tool"
+    tool3.custom_name = "Team2_Tool"
     tool3.owner_email = "user2@example.com"
     tool3.team_id = "team2"
     tool3.visibility = "team"
@@ -273,7 +277,7 @@ async def test_full_payload_generation_with_mock_db():
         # Verify backend configuration
         server1 = user1_config["virtual_hosts"]["s1"]
         assert "backends" in server1
-        assert "g1" in server1["backends"]
+        assert "g1" in server1["backends"], "backends must be keyed by gateway ID"
 
         backend = server1["backends"]["g1"]
         assert backend["name"] == "Gateway 1"
@@ -282,6 +286,7 @@ async def test_full_payload_generation_with_mock_db():
         assert backend["passthrough_headers"] == ["Authorization"]
         assert backend["capabilities"] == {"resources": {"subscribe": True}}
         assert backend["allowed_tool_names"] == ["public_tool", "private_tool"]
+        assert backend["tool_name_aliases"] == {"Public.Tool": "public_tool", "Private-Tool": "private_tool"}
         assert backend["allowed_resource_names"] == ["Resource 1"]
         assert backend["allowed_resource_uris"] == ["resource://one"]
         assert backend["allowed_prompt_names"] == ["Prompt 1"]
@@ -294,6 +299,7 @@ async def test_full_payload_generation_with_mock_db():
         assert "s2" not in user2_config["virtual_hosts"]
         user2_backend = user2_config["virtual_hosts"]["s1"]["backends"]["g1"]
         assert user2_backend["allowed_tool_names"] == ["public_tool", "team2_tool"]
+        assert user2_backend["tool_name_aliases"] == {"Public.Tool": "public_tool", "Team2_Tool": "team2_tool"}
 
         # Verify active users with no team membership still get public-only config.
         user3_config = payload["user3@example.com"]
@@ -301,6 +307,7 @@ async def test_full_payload_generation_with_mock_db():
         assert "s2" not in user3_config["virtual_hosts"]
         user3_backend = user3_config["virtual_hosts"]["s1"]["backends"]["g1"]
         assert user3_backend["allowed_tool_names"] == ["public_tool"]
+        assert user3_backend["tool_name_aliases"] == {"Public.Tool": "public_tool"}
 
 
 # ============================================================================
@@ -422,6 +429,56 @@ def test_create_payload_excludes_non_streamable_gateways():
     assert result["user@example.com"]["virtual_hosts"] == {}
 
 
+def test_create_payload_keeps_gateways_with_the_same_slug():
+    """Gateway IDs prevent same-slug streamable backends from overwriting each other."""
+    from mcpgateway.services.dataplane_publisher import DataplanePublisherService
+
+    service = DataplanePublisherService()
+    data = {
+        "user@example.com": {
+            "servers": [
+                {
+                    "id": "server1",
+                    "backend_items": {
+                        "gateway1": {"tools": ["tool1"], "resources": [], "prompts": []},
+                        "gateway2": {"tools": ["tool2"], "resources": [], "prompts": []},
+                    },
+                }
+            ],
+            "gateways": [
+                {"id": "gateway1", "name": "Shared Name", "url": "http://one.example/mcp", "transport": "STREAMABLEHTTP", "passthrough_headers": []},
+                {"id": "gateway2", "name": "Shared Name", "url": "http://two.example/mcp", "transport": "STREAMABLEHTTP", "passthrough_headers": []},
+            ],
+            "prompts": [],
+            "resources": [],
+        }
+    }
+
+    backends = service.create_payload(data)["user@example.com"]["virtual_hosts"]["server1"]["backends"]
+
+    assert set(backends) == {"gateway1", "gateway2"}
+    assert backends["gateway1"]["url"] == "http://one.example/mcp"
+    assert backends["gateway2"]["url"] == "http://two.example/mcp"
+
+
+def test_filter_backend_items_keeps_first_alias_on_duplicate_exposed_name(caplog):
+    """Duplicate exposed names on one backend keep the first alias and warn instead of silently overwriting."""
+    from mcpgateway.services.dataplane_publisher import DataplanePublisherService
+
+    backend_items = {"g1": {"tools": ["tool1", "tool2"], "resources": [], "prompts": []}}
+    tool_names_by_id = {
+        "tool1": ("upstream_one", "Shared.Name"),
+        "tool2": ("upstream_two", "Shared.Name"),
+    }
+
+    with caplog.at_level(logging.WARNING, logger="mcpgateway.services.dataplane_publisher"):
+        filtered = DataplanePublisherService._filter_backend_items_for_user(backend_items, tool_names_by_id)
+
+    assert filtered["g1"]["tools"] == ["upstream_one", "upstream_two"]
+    assert filtered["g1"]["tool_name_aliases"] == {"Shared.Name": "upstream_one"}
+    assert "Duplicate exposed tool name 'Shared.Name'" in caplog.text
+
+
 def test_create_payload_normalizes_null_passthrough_headers():
     """create_payload() emits an empty list for gateways without passthrough headers."""
     from mcpgateway.services.dataplane_publisher import DataplanePublisherService
diff --git a/tests/unit/mcpgateway/services/test_metrics_exception_coverage.py b/tests/unit/mcpgateway/services/test_metrics_exception_coverage.py
index af5156c1a2..7bf008c4ea 100644
--- a/tests/unit/mcpgateway/services/test_metrics_exception_coverage.py
+++ b/tests/unit/mcpgateway/services/test_metrics_exception_coverage.py
@@ -252,6 +252,8 @@ async def fake_get(*a, **kw):
 
         with (
             _setup_cache_for_invoke(tp),
+            patch.object(tool_service, "_load_invocable_tools", return_value=[MagicMock(enabled=True, reachable=True, gateway=None)]),
+            patch.object(tool_service, "_build_tool_cache_payload", return_value={"tool": tp, "gateway": None}),
             patch.object(tool_service, "_check_tool_access", AsyncMock(return_value=True)),
             patch("mcpgateway.services.tool_service.global_config_cache") as mock_gcc,
             patch("mcpgateway.services.tool_service.current_trace_id") as mock_trace,
diff --git a/tests/unit/mcpgateway/services/test_server_service.py b/tests/unit/mcpgateway/services/test_server_service.py
index b693659443..ffe1c26007 100644
--- a/tests/unit/mcpgateway/services/test_server_service.py
+++ b/tests/unit/mcpgateway/services/test_server_service.py
@@ -737,14 +737,19 @@ async def test_update_server(self, server_service, mock_server, test_db, mock_to
         )
 
         test_user_email = "user@example.com"
+        tool_lookup_cache = MagicMock(invalidate_server=AsyncMock())
 
         # Patch permission check to avoid consuming db.execute side-effects
-        with patch("mcpgateway.services.permission_service.PermissionService.check_resource_ownership", new=AsyncMock(return_value=True)):
+        with (
+            patch("mcpgateway.services.permission_service.PermissionService.check_resource_ownership", new=AsyncMock(return_value=True)),
+            patch("mcpgateway.services.server_service._get_tool_lookup_cache", return_value=tool_lookup_cache),
+        ):
             result = await server_service.update_server(test_db, 1, server_update, test_user_email)
 
         test_db.commit.assert_called_once()
         test_db.refresh.assert_called_once()
         server_service._notify_server_updated.assert_called_once()
+        tool_lookup_cache.invalidate_server.assert_awaited_once_with("550e8400e29b41d4a716446655440001")  # pragma: allowlist secret
         assert result.name == "updated_server"
 
     @pytest.mark.asyncio
@@ -1052,13 +1057,16 @@ async def test_delete_server(self, server_service, mock_server, test_db):
         test_db.delete = Mock()
         test_db.commit = Mock()
         server_service._notify_server_deleted = AsyncMock()
+        tool_lookup_cache = MagicMock(invalidate_server=AsyncMock())
 
-        await server_service.delete_server(test_db, 1)
+        with patch("mcpgateway.services.server_service._get_tool_lookup_cache", return_value=tool_lookup_cache):
+            await server_service.delete_server(test_db, 1)
 
         test_db.get.assert_called_once_with(DbServer, 1)
         test_db.delete.assert_called_once_with(mock_server)
         test_db.commit.assert_called_once()
         server_service._notify_server_deleted.assert_called_once()
+        tool_lookup_cache.invalidate_server.assert_awaited_once_with("550e8400e29b41d4a716446655440001")  # pragma: allowlist secret
 
     @pytest.mark.asyncio
     async def test_delete_server_purge_metrics(self, server_service, mock_server, test_db):
diff --git a/tests/unit/mcpgateway/services/test_tool_service.py b/tests/unit/mcpgateway/services/test_tool_service.py
index a758cd0130..4b7237ecc8 100644
--- a/tests/unit/mcpgateway/services/test_tool_service.py
+++ b/tests/unit/mcpgateway/services/test_tool_service.py
@@ -31,6 +31,7 @@
 from mcpgateway.cache.tool_lookup_cache import tool_lookup_cache
 from mcpgateway.config import settings
 from mcpgateway.db import Gateway as DbGateway
+from mcpgateway.db import Server as DbServer
 from mcpgateway.db import Tool as DbTool
 from mcpgateway.schemas import AuthenticationValues, ToolCreate, ToolRead, ToolUpdate
 from mcpgateway.services.tool_service import (
@@ -9203,6 +9204,7 @@ async def test_invoke_tool_prefers_exact_name_over_original_name_collision(self,
             )
 
         build_payload.assert_called_once_with(exact_name_tool, selected_gateway)
+        cache.get.assert_awaited_once_with("helper", server_id="server-1")
         tool_service._http_client.get.assert_awaited_once_with("http://tool.example/invoke", params={}, headers={})
         assert result.content[0].text == '{\n  "ok": true\n}'
 
@@ -9261,6 +9263,9 @@ async def test_list_server_mcp_tool_definitions_public_only_and_output_schema(se
             token_teams=["team-a"],
         )
 
+        query = str(db.execute.call_args.args[0])
+        assert "tools.custom_name AS name" in query
+
         assert payload == [
             {
                 "name": "tool-public",
@@ -9279,6 +9284,30 @@ async def test_list_server_mcp_tool_definitions_public_only_and_output_schema(se
         ]
         db.commit.assert_called_once()
 
+    @pytest.mark.asyncio
+    async def test_list_server_mcp_tool_definitions_warns_on_duplicate_exposed_names(self, tool_service, caplog):
+        """Duplicate exposed custom names within one server should be surfaced as a warning."""
+        row = {
+            "name": "Shared.Tool",
+            "title": None,
+            "description": "desc",
+            "input_schema": {"type": "object"},
+            "output_schema": None,
+            "annotations": None,
+            "owner_email": None,
+            "team_id": None,
+            "visibility": "public",
+        }
+        db = MagicMock()
+        db.execute.return_value.mappings.return_value.all.return_value = [row, dict(row)]
+
+        with caplog.at_level(logging.WARNING, logger="mcpgateway.services.tool_service"):
+            payload = await tool_service.list_server_mcp_tool_definitions(db, "srv-1", user_email=None, token_teams=None)
+
+        assert [definition["name"] for definition in payload] == ["Shared.Tool", "Shared.Tool"]
+        assert "duplicate tool names" in caplog.text
+        assert "srv-1" in caplog.text
+
     @pytest.mark.asyncio
     async def test_prepare_rust_mcp_tool_execution_post_invoke_hooks_force_fallback(self, tool_service):
         """Post-invoke hooks should force fallback even when pre-invoke hooks are also registered."""
@@ -9618,6 +9647,92 @@ async def test_prepare_rust_mcp_tool_execution_rejects_ambiguous_accessible_tool
             with pytest.raises(ToolInvocationError, match="ambiguous"):
                 await tool_service.prepare_rust_mcp_tool_execution(MagicMock(), "tool-one", user_email="user@example.com", token_teams=["team-a"])
 
+    @pytest.mark.asyncio
+    async def test_prepare_rust_mcp_tool_execution_prefers_server_custom_name_over_original_name_collision(self, tool_service, test_db):
+        """An exact custom-name match should beat an original-name fallback."""
+        server = DbServer(id="server-alias-collision", name="Alias Collision Server")
+        custom_name_gateway = DbGateway(id="gateway-custom-name-match", name="Custom Name Gateway", slug="custom-name-gateway", url="https://custom.example/mcp", capabilities={})
+        original_name_gateway = DbGateway(id="gateway-original-name-match", name="Original Name Gateway", slug="original-name-gateway", url="https://original.example/mcp", capabilities={})
+        custom_name_match = DbTool(
+            id="tool-custom-name-match",
+            original_name="upstream-custom-name",
+            custom_name="shared-name",
+            custom_name_slug="shared-name",
+            input_schema={},
+            visibility="public",
+            gateway=custom_name_gateway,
+        )
+        original_name_match = DbTool(
+            id="tool-original-name-match",
+            original_name="shared-name",
+            custom_name="different-name",
+            custom_name_slug="different-name",
+            input_schema={},
+            visibility="public",
+            gateway=original_name_gateway,
+        )
+        server.tools.extend([custom_name_match, original_name_match])
+        test_db.add_all([server, custom_name_gateway, original_name_gateway])
+        test_db.flush()
+        candidates = tool_service._load_invocable_tools(test_db, "shared-name", server_id=server.id)
+        assert {tool.id for tool in candidates} == {"tool-custom-name-match", "tool-original-name-match"}
+        assert all(tool.name != "shared-name" for tool in candidates)
+        cache = self._cache_mock(None)
+        cache_payload = self._cache_payload(original_name="upstream-custom-name")
+
+        with (
+            patch("mcpgateway.services.tool_service._get_tool_lookup_cache", return_value=cache),
+            patch("mcpgateway.services.tool_service.current_trace_id", MagicMock(get=MagicMock(return_value=None))),
+            patch("mcpgateway.services.tool_service.global_config_cache.get_passthrough_headers", return_value=[]),
+            patch("mcpgateway.services.tool_service.compute_passthrough_headers_cached", return_value={}),
+            patch.object(tool_service, "_build_tool_cache_payload", return_value=cache_payload) as build_cache_payload,
+            patch.object(tool_service, "_check_tool_access", AsyncMock(return_value=True)),
+            patch.object(tool_service, "_get_plugin_manager", AsyncMock(return_value=None)),
+        ):
+            plan = await tool_service.prepare_rust_mcp_tool_execution(test_db, "shared-name", server_id=server.id, user_email="user@example.com")
+
+        assert plan["remoteToolName"] == "upstream-custom-name"
+        build_cache_payload.assert_called_once_with(custom_name_match, custom_name_gateway)
+        cache.get.assert_awaited_once_with("shared-name", server_id=server.id)
+        cache.set.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_prepare_rust_mcp_tool_execution_rejects_server_custom_name_internal_name_collision(self, tool_service):
+        """An exact custom-name match must tie an exact stored-name match and fail closed."""
+        cache = self._cache_mock(None)
+        gateway = SimpleNamespace(id="gw-1")
+        internal_name_match = SimpleNamespace(
+            name="public-tool",
+            custom_name="friendly-name",
+            original_name="upstream-internal",
+            visibility="public",
+            team_id=None,
+            owner_email=None,
+            gateway=gateway,
+        )
+        custom_name_match = SimpleNamespace(
+            name="other-gateway-tool",
+            custom_name="public-tool",
+            original_name="upstream-custom",
+            visibility="public",
+            team_id=None,
+            owner_email=None,
+            gateway=gateway,
+        )
+
+        with (
+            patch("mcpgateway.services.tool_service._get_tool_lookup_cache", return_value=cache),
+            patch("mcpgateway.services.tool_service.current_trace_id", MagicMock(get=MagicMock(return_value=None))),
+            patch.object(tool_service, "_load_invocable_tools", return_value=[internal_name_match, custom_name_match]),
+            patch.object(tool_service, "_check_tool_access", AsyncMock(return_value=True)),
+            patch.object(tool_service, "_get_plugin_manager", AsyncMock(return_value=None)),
+        ):
+            with pytest.raises(ToolInvocationError, match="ambiguous"):
+                await tool_service.prepare_rust_mcp_tool_execution(MagicMock(), "public-tool", server_id="srv-1", user_email="user@example.com")
+
+        cache.get.assert_awaited_once_with("public-tool", server_id="srv-1")
+        cache.set.assert_not_awaited()
+
     @pytest.mark.asyncio
     async def test_prepare_rust_mcp_tool_execution_selects_highest_priority_accessible_candidate(self, tool_service):
         """A single best-priority accessible candidate should be selected successfully."""
@@ -9836,18 +9951,25 @@ async def test_prepare_rust_mcp_tool_execution_rejects_cached_payload_when_acces
                 await tool_service.prepare_rust_mcp_tool_execution(MagicMock(), "tool-one", user_email="user@example.com", token_teams=["team-a"])
 
     @pytest.mark.asyncio
-    async def test_prepare_rust_mcp_tool_execution_rejects_server_scoped_cached_payload_without_tool_id(self, tool_service):
-        """Server-scoped cached payloads need a concrete tool id for membership checks."""
-        cache = self._cache_mock(self._cache_payload(id=None))
+    async def test_prepare_rust_mcp_tool_execution_uses_server_scoped_cache_for_aliases(self, tool_service):
+        """Server aliases should use their isolated server-scoped cache entries."""
+        cache = self._cache_mock(self._cache_payload())
+        db = MagicMock()
 
         with (
             patch("mcpgateway.services.tool_service._get_tool_lookup_cache", return_value=cache),
             patch("mcpgateway.services.tool_service.current_trace_id", MagicMock(get=MagicMock(return_value=None))),
+            patch.object(tool_service, "_load_invocable_tools", return_value=[]) as load_invocable_tools,
             patch.object(tool_service, "_check_tool_access", AsyncMock(return_value=True)),
+            patch("mcpgateway.services.tool_service.global_config_cache.get_passthrough_headers", return_value=[]),
             patch.object(tool_service, "_get_plugin_manager", AsyncMock(return_value=None)),
         ):
-            with pytest.raises(ToolNotFoundError, match="Tool not found"):
-                await tool_service.prepare_rust_mcp_tool_execution(MagicMock(), "tool-one", server_id="srv-1")
+            plan = await tool_service.prepare_rust_mcp_tool_execution(db, "tool-one", server_id="srv-1")
+
+        assert plan["eligible"] is True
+        cache.get.assert_awaited_once_with("tool-one", server_id="srv-1")
+        load_invocable_tools.assert_not_called()
+        db.execute.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_prepare_rust_mcp_tool_execution_uses_live_gateway_auth_fields_for_loaded_tools(self, tool_service):
@@ -10065,7 +10187,7 @@ async def test_prepare_rust_mcp_tool_execution_hydrates_gateway_string_auth_from
         assert plan["headers"] == {"Authorization": "Bearer hydrated-string"}
 
     def test_load_invocable_tools_applies_server_scope_filter(self, tool_service):
-        """Server-scoped tool loading should join through the server association table."""
+        """Server-scoped tool loading resolves the exposed custom name."""
         db = MagicMock()
         result = MagicMock()
         result.scalars.return_value.all.return_value = []
@@ -10073,6 +10195,21 @@ def test_load_invocable_tools_applies_server_scope_filter(self, tool_service):
 
         assert tool_service._load_invocable_tools(db, "tool-one", server_id="srv-1") == []
         db.execute.assert_called_once()
+        where_clause = str(db.execute.call_args.args[0].whereclause)
+        assert "tools.custom_name" in where_clause
+        assert "server_tool_association.server_id" in where_clause
+
+    def test_load_invocable_tools_uses_global_name_without_server_scope(self, tool_service):
+        """Global tool loading keeps resolving the namespaced internal name."""
+        db = MagicMock()
+        result = MagicMock()
+        result.scalars.return_value.all.return_value = []
+        db.execute.return_value = result
+
+        assert tool_service._load_invocable_tools(db, "gateway-tool-one") == []
+        where_clause = str(db.execute.call_args.args[0].whereclause)
+        assert "tools.name" in where_clause
+        assert "tools.custom_name" not in where_clause
 
     @pytest.mark.asyncio
     @pytest.mark.parametrize(
@@ -10116,20 +10253,30 @@ async def test_prepare_rust_mcp_tool_execution_allows_sse_transport(self, tool_s
         assert plan["transport"] == "sse"
 
     @pytest.mark.asyncio
-    async def test_prepare_rust_mcp_tool_execution_checks_server_membership(self, tool_service):
-        """Server-scoped execution should reject tools not attached to the requested server."""
-        cache = self._cache_mock(self._cache_payload())
+    async def test_prepare_rust_mcp_tool_execution_routes_server_alias_to_original_name(self, tool_service):
+        """A server-scoped custom alias should invoke the upstream original name."""
+        cache = self._cache_mock(None)
+        cache_payload = self._cache_payload(original_name="upstream-tool")
+        gateway = SimpleNamespace(id="gw-1")
+        tool = SimpleNamespace(enabled=True, reachable=True, visibility="public", team_id=None, owner_email=None, gateway=gateway)
         db = MagicMock()
-        db.execute.return_value.first.return_value = None
 
         with (
             patch("mcpgateway.services.tool_service._get_tool_lookup_cache", return_value=cache),
             patch("mcpgateway.services.tool_service.current_trace_id", MagicMock(get=MagicMock(return_value=None))),
+            patch.object(tool_service, "_load_invocable_tools", return_value=[tool]) as load_invocable_tools,
+            patch.object(tool_service, "_build_tool_cache_payload", return_value=cache_payload),
             patch.object(tool_service, "_check_tool_access", AsyncMock(return_value=True)),
+            patch("mcpgateway.services.tool_service.global_config_cache.get_passthrough_headers", return_value=[]),
+            patch("mcpgateway.services.tool_service.compute_passthrough_headers_cached", return_value={}),
             patch.object(tool_service, "_get_plugin_manager", AsyncMock(return_value=None)),
         ):
-            with pytest.raises(ToolNotFoundError, match="Tool not found"):
-                await tool_service.prepare_rust_mcp_tool_execution(db, "tool-one", server_id="srv-1")
+            plan = await tool_service.prepare_rust_mcp_tool_execution(db, "Custom.Tool", server_id="srv-1")
+
+        assert plan["remoteToolName"] == "upstream-tool"
+        cache.get.assert_awaited_once_with("Custom.Tool", server_id="srv-1")
+        cache.set.assert_awaited_once_with("Custom.Tool", cache_payload, gateway_id="gw-1", server_id="srv-1")
+        load_invocable_tools.assert_called_once_with(db, "Custom.Tool", server_id="srv-1")
 
     @pytest.mark.asyncio
     async def test_prepare_rust_mcp_tool_execution_handles_query_param_auth_and_passthrough(self, tool_service):
diff --git a/tests/unit/mcpgateway/services/test_tool_service_coverage.py b/tests/unit/mcpgateway/services/test_tool_service_coverage.py
index f7435027b9..af11399fe8 100644
--- a/tests/unit/mcpgateway/services/test_tool_service_coverage.py
+++ b/tests/unit/mcpgateway/services/test_tool_service_coverage.py
@@ -5431,24 +5431,18 @@ async def test_access_denied_returns_not_found(self, tool_service):
     @pytest.mark.asyncio
     async def test_server_scoping_denies_unattached_tool(self, tool_service):
         """Tool not attached to specified server raises not found."""
-        with patch("mcpgateway.services.tool_service._get_tool_lookup_cache") as mock_cache_fn, patch.object(tool_service, "_check_tool_access", AsyncMock(return_value=True)):
-            mock_cache = AsyncMock()
-            mock_cache.enabled = True
-            mock_cache.get = AsyncMock(
-                return_value={
-                    "status": "active",
-                    "tool": {"enabled": True, "reachable": True, "id": "t1", "visibility": "public", "integration_type": "REST", "annotations": {}},
-                    "gateway": None,
-                }
-            )
-            mock_cache_fn.return_value = mock_cache
-
+        mock_cache = AsyncMock()
+        mock_cache.enabled = True
+        mock_cache.get = AsyncMock(return_value=None)
+        with patch("mcpgateway.services.tool_service._get_tool_lookup_cache", return_value=mock_cache), patch.object(tool_service, "_load_invocable_tools", return_value=[]) as load_invocable_tools:
             db = MagicMock()
-            db.execute = MagicMock(return_value=MagicMock(first=MagicMock(return_value=None)))
 
             with pytest.raises(ToolNotFoundError, match="not found"):
                 await tool_service.invoke_tool(db, "tool", {}, server_id="srv-1")
 
+        mock_cache.get.assert_awaited_once_with("tool", server_id="srv-1")
+        load_invocable_tools.assert_called_once_with(db, "tool", server_id="srv-1")
+
     @pytest.mark.asyncio
     async def test_server_scoping_allows_attached_tool(self, tool_service):
         """Tool attached to specified server should pass scoping check and invoke normally."""
@@ -5463,6 +5457,8 @@ async def test_server_scoping_allows_attached_tool(self, tool_service):
 
         with (
             _setup_cache_for_invoke(tp),
+            patch.object(tool_service, "_load_invocable_tools", return_value=[MagicMock(enabled=True, reachable=True, gateway=None)]),
+            patch.object(tool_service, "_build_tool_cache_payload", return_value={"tool": tp, "gateway": None}),
             patch.object(tool_service, "_check_tool_access", AsyncMock(return_value=True)),
             patch("mcpgateway.services.tool_service.global_config_cache") as mock_gcc,
             patch("mcpgateway.services.tool_service.current_trace_id") as mock_trace,
@@ -6193,6 +6189,7 @@ def _make_tool_payload(
         "auth_value": auth_value,
         "oauth_config": None,
         "enabled": True,
+        "deprecated": False,
         "reachable": True,
         "gateway_id": gateway_id,
         "visibility": "public",
diff --git a/tests/unit/mcpgateway/test_main.py b/tests/unit/mcpgateway/test_main.py
index 6eb381158b..4f2bc7c2fc 100644
--- a/tests/unit/mcpgateway/test_main.py
+++ b/tests/unit/mcpgateway/test_main.py
@@ -15,6 +15,7 @@
 import json
 import logging
 import os
+from types import SimpleNamespace
 from unittest.mock import ANY, AsyncMock, MagicMock, patch
 
 
@@ -2732,6 +2733,37 @@ def test_rpc_list_tools_with_server_id(self, mock_list_tools, test_client, auth_
         assert body["result"]["tools"][0]["name"] == "test_tool"
         mock_list_tools.assert_called_once()
 
+    @patch("mcpgateway.main.tool_service.list_server_tools", new_callable=AsyncMock)
+    def test_rpc_list_tools_with_server_id_aligns_custom_names_after_apps_filtering(self, mock_list_tools, test_client, auth_headers):
+        """App-only filtering must not shift custom names onto later visible tools."""
+        extension_key = "io.modelcontextprotocol/ui"
+
+        def _tool(name: str, custom_name: str, visibility: str) -> SimpleNamespace:
+            return SimpleNamespace(
+                name=name,
+                custom_name=custom_name,
+                title=None,
+                description=name,
+                input_schema={"type": "object"},
+                output_schema=None,
+                annotations=None,
+                extension_metadata={extension_key: {"visibility": [visibility]}},
+            )
+
+        mock_list_tools.return_value = [
+            _tool("internal-first", "First.Tool", "model"),
+            _tool("internal-helper", "Helper.Tool", "app"),
+            _tool("internal-last", "Last.Tool", "model"),
+        ]
+        req = {"jsonrpc": "2.0", "id": "test-id", "method": "tools/list", "params": {"server_id": "server-1"}}
+
+        with patch("mcpgateway.services.mcp_apps.settings.mcpgateway_mcp_apps_enabled", True):
+            response = test_client.post("/rpc/", json=req, headers=auth_headers)
+
+        assert response.status_code == 200
+        assert [tool["name"] for tool in response.json()["result"]["tools"]] == ["First.Tool", "Last.Tool"]
+        mock_list_tools.assert_called_once()
+
     @patch("mcpgateway.main.tool_service.list_tools")
     def test_rpc_legacy_list_tools_next_cursor(self, mock_list_tools, test_client, auth_headers):
         """Test legacy list_tools JSON-RPC method with nextCursor."""
diff --git a/tests/unit/mcpgateway/test_main_extended.py b/tests/unit/mcpgateway/test_main_extended.py
index 4336f6f80d..a5e64c0e40 100644
--- a/tests/unit/mcpgateway/test_main_extended.py
+++ b/tests/unit/mcpgateway/test_main_extended.py
@@ -6579,7 +6579,9 @@ async def test_handle_rpc_tools_list_server(self):
         request = self._make_request(payload)
 
         tool = MagicMock()
-        tool.model_dump.return_value = {"id": "tool-1"}
+        tool.name = "gateway-tool"
+        tool.custom_name = "Custom.Tool"
+        tool.model_dump.return_value = {"id": "tool-1", "name": "gateway-tool", "description": "", "input_schema": {"type": "object"}}
         mock_db = MagicMock()
 
         with (
@@ -6588,6 +6590,7 @@ async def test_handle_rpc_tools_list_server(self):
         ):
             result = await handle_rpc(request, db=mock_db, user={"email": "user@example.com"})
             assert len(result["result"]["tools"]) == 1
+            assert result["result"]["tools"][0]["name"] == "Custom.Tool"
             assert mock_list_server_tools.await_args.args[1] == "srv"
 
     async def test_handle_rpc_tools_list_uses_internal_rust_server_header(self):
diff --git a/tests/unit/mcpgateway/transports/test_streamablehttp_transport.py b/tests/unit/mcpgateway/transports/test_streamablehttp_transport.py
index 0095029f67..5a589d3371 100644
--- a/tests/unit/mcpgateway/transports/test_streamablehttp_transport.py
+++ b/tests/unit/mcpgateway/transports/test_streamablehttp_transport.py
@@ -1082,7 +1082,8 @@ async def test_list_tools_with_server_id(monkeypatch):
     """Test list_tools returns tools for a server_id."""
     mock_db = MagicMock()
     mock_tool = MagicMock()
-    mock_tool.name = "t"
+    mock_tool.name = "gateway-t"
+    mock_tool.custom_name = "Custom.Tool"
     mock_tool.title = "Tool Title"
     mock_tool.description = "desc"
     mock_tool.input_schema = {"type": "object"}
@@ -1102,7 +1103,7 @@ async def fake_get_db():
     result = await list_tools()
 
     assert isinstance(result, list)
-    assert result[0].name == "t"
+    assert result[0].name == "Custom.Tool"
     assert getattr(result[0], "title", None) == "Tool Title"
     assert result[0].description == "desc"
 
diff --git a/tests/unit/mcpgateway/utils/test_error_formatter.py b/tests/unit/mcpgateway/utils/test_error_formatter.py
index 116d235bce..326960ae4b 100644
--- a/tests/unit/mcpgateway/utils/test_error_formatter.py
+++ b/tests/unit/mcpgateway/utils/test_error_formatter.py
@@ -19,6 +19,7 @@
 from sqlalchemy.exc import DatabaseError, IntegrityError
 
 # First-Party
+from mcpgateway.schemas import ToolCreate
 from mcpgateway.utils.error_formatter import ErrorFormatter, sanitize_validation_error_for_log
 
 
@@ -28,9 +29,9 @@ class NameModel(BaseModel):
     @field_validator("name")
     def validate_name(cls, v):
         if not v.startswith("A"):
-            raise ValueError("Tool name must start with a letter, number, or underscore")
-        if len(v) > 255:
-            raise ValueError("Tool name exceeds maximum length")
+            raise ValueError("Tool name may contain only letters, numbers, underscores, hyphens, and periods")
+        if len(v) > 128:
+            raise ValueError(f"Tool name exceeds MCP spec limit of 128 characters (got {len(v)})")
         return v
 
 
@@ -87,23 +88,23 @@ def test_format_validation_error_empty_errors_verbose(monkeypatch):
     assert result["message"] == "Validation failed: Validation error"
 
 
-def test_format_validation_error_letter_requirement(monkeypatch):
+def test_format_validation_error_tool_name_characters(monkeypatch):
     monkeypatch.setattr("mcpgateway.utils.error_formatter.should_expose_error_details", lambda: True)
     with pytest.raises(ValidationError) as exc:
         NameModel(name="Bobby")
     result = ErrorFormatter.format_validation_error(exc.value)
-    assert result["message"] == "Validation failed: Name must start with a letter, number, or underscore and contain only letters, numbers, periods, underscores, hyphens, and slashes"
+    assert result["message"] == "Validation failed: Name may contain only letters, numbers, periods, underscores, and hyphens"
     assert result["success"] is False
     assert result["details"][0]["field"] == "name"
-    assert "must start with a letter, number, or underscore" in result["details"][0]["message"]
+    assert "may contain only" in result["details"][0]["message"]
 
 
 def test_format_validation_error_length(monkeypatch):
     monkeypatch.setattr("mcpgateway.utils.error_formatter.should_expose_error_details", lambda: True)
     with pytest.raises(ValidationError) as exc:
-        NameModel(name="A" * 300)
+        ToolCreate(name="A" * 129, inputSchema={})
     result = ErrorFormatter.format_validation_error(exc.value)
-    assert "too long" in result["details"][0]["message"]
+    assert result["details"][0]["message"] == "Name is too long (maximum 128 characters)"
 
 
 def test_format_validation_error_url(monkeypatch):
@@ -155,8 +156,8 @@ class MultiModel(BaseModel):
 
         @field_validator("name")
         def validate_name(cls, v):
-            if len(v) > 255:
-                raise ValueError("Tool name exceeds maximum length")
+            if len(v) > 128:
+                raise ValueError(f"Tool name exceeds MCP spec limit of 128 characters (got {len(v)})")
             return v
 
         @field_validator("url")
@@ -176,8 +177,8 @@ def validate_url(cls, v):
 
 def test_get_user_message_all_patterns():
     # Directly test _get_user_message for all mappings and fallback
-    assert "must start with a letter, number, or underscore" in ErrorFormatter._get_user_message("name", "Tool name must start with a letter, number, or underscore")
-    assert "too long" in ErrorFormatter._get_user_message("description", "Tool name exceeds maximum length")
+    assert "may contain only" in ErrorFormatter._get_user_message("name", "Tool name may contain only letters")
+    assert ErrorFormatter._get_user_message("description", "Tool name exceeds MCP spec limit of 128 characters (got 129)") == "Description is too long (maximum 128 characters)"
     assert "valid HTTP" in ErrorFormatter._get_user_message("endpoint", "Tool URL must start with http")
     assert "invalid characters" in ErrorFormatter._get_user_message("path", "cannot contain directory traversal")
     assert "cannot contain HTML" in ErrorFormatter._get_user_message("content", "contains HTML tags")
diff --git a/tests/unit/mcpgateway/validation/test_validators.py b/tests/unit/mcpgateway/validation/test_validators.py
index e2cb776af7..5d245bc290 100644
--- a/tests/unit/mcpgateway/validation/test_validators.py
+++ b/tests/unit/mcpgateway/validation/test_validators.py
@@ -26,7 +26,7 @@ class DummySettings:
     validation_identifier_pattern = r"^[a-zA-Z0-9_\-\.]+$"
     validation_safe_uri_pattern = r"^[a-zA-Z0-9_\-.:/?=&%{}]+$"
     validation_unsafe_uri_pattern = r"[<>\"'\\]"
-    validation_tool_name_pattern = r"^[a-zA-Z0-9_][a-zA-Z0-9._/-]*$"  # SEP-986 pattern
+    validation_tool_name_pattern = r"^[a-zA-Z0-9_.-]+$"  # MCP 2025-11-25 pattern
     validation_max_name_length = 10  # Increased for realistic URIs
     validation_max_description_length = 100
     validation_max_template_length = 100
@@ -204,10 +204,15 @@ def test_validate_tool_name_empty():
         SecurityValidator.validate_tool_name("")
 
 
-def test_validate_tool_name_invalid():
-    # Leading hyphen is not allowed
+@pytest.mark.parametrize("name", ["namespace/tool", "tool\n"])
+def test_validate_tool_name_invalid(name):
     with pytest.raises(ValueError):
-        SecurityValidator.validate_tool_name("-bad")
+        SecurityValidator.validate_tool_name(name)
+
+
+@pytest.mark.parametrize("name", ["-tool", ".tool", "Tool.Name-1_test"])
+def test_validate_tool_name_allows_spec_characters(name):
+    assert SecurityValidator.validate_tool_name(name) == name
 
 
 def test_validate_tool_name_html():
diff --git a/tests/unit/mcpgateway/validation/test_validators_advanced.py b/tests/unit/mcpgateway/validation/test_validators_advanced.py
index 3f5a630a94..51053617d4 100644
--- a/tests/unit/mcpgateway/validation/test_validators_advanced.py
+++ b/tests/unit/mcpgateway/validation/test_validators_advanced.py
@@ -58,7 +58,7 @@ class DummySettings:
     validation_identifier_pattern = r"^[a-zA-Z0-9_\-\.]+$"  # IDs cannot have spaces
     validation_safe_uri_pattern = r"^[a-zA-Z0-9_\-.:/?=&%{}]+$"
     validation_unsafe_uri_pattern = r'[<>"\'\\]'
-    validation_tool_name_pattern = r"^[a-zA-Z0-9_][a-zA-Z0-9._/-]*$"  # SEP-986 pattern
+    validation_tool_name_pattern = r"^[a-zA-Z0-9_.-]+$"  # MCP 2025-11-25 pattern
 
     # Size limits for various fields
     validation_max_name_length = 100  # Realistic name length
@@ -513,15 +513,16 @@ def test_validate_tool_name_invalid():
     with pytest.raises(ValueError, match="cannot be empty"):
         SecurityValidator.validate_tool_name("")
 
-    # Names starting with hyphen are invalid (not in [a-zA-Z0-9_])
-    with pytest.raises(ValueError, match="must start with a letter, number, or underscore"):
-        SecurityValidator.validate_tool_name("-tool")
+    assert SecurityValidator.validate_tool_name("-tool") == "-tool"
+    assert SecurityValidator.validate_tool_name(".tool") == ".tool"
 
     # Tool name pattern doesn't match - contains invalid characters
-    with pytest.raises(ValueError, match="must start with a letter, number, or underscore"):
+    with pytest.raises(ValueError, match="may contain only"):
         SecurityValidator.validate_tool_name("tool<name>")
-    with pytest.raises(ValueError, match="must start with a letter, number, or underscore"):
+    with pytest.raises(ValueError, match="may contain only"):
         SecurityValidator.validate_tool_name('tool"name')
+    with pytest.raises(ValueError, match="may contain only"):
+        SecurityValidator.validate_tool_name("tool/name")
 
 
 def test_validate_tool_name_valid_with_leading_underscore_or_number():