Fix the baseUrl is configured with a trailing slash

Signed-off-by: lance <leehaut@gmail.com>

Author: leehaut

mcp-core/src/main/java/io/modelcontextprotocol/server/transport/HttpServletSseServerTransportProvider.java

@@ -26,6 +26,7 @@
 import io.modelcontextprotocol.spec.ProtocolVersions;
 import io.modelcontextprotocol.util.Assert;
 import io.modelcontextprotocol.util.KeepAliveScheduler;
+import io.modelcontextprotocol.util.UriBuilder;
 import jakarta.servlet.AsyncContext;
 import jakarta.servlet.ServletException;
 import jakarta.servlet.annotation.WebServlet;
@@ -87,6 +88,8 @@ public class HttpServletSseServerTransportProvider extends HttpServlet implement
 	/** Event type for endpoint information */
 	public static final String ENDPOINT_EVENT_TYPE = "endpoint";
 
+	public static final String SESSION_ID = "sessionId";
+
 	public static final String DEFAULT_BASE_URL = "";
 
 	/** JSON mapper for serialization/deserialization */
@@ -243,7 +246,17 @@ protected void doGet(HttpServletRequest request, HttpServletResponse response)
 		this.sessions.put(sessionId, session);
 
 		// Send initial endpoint event
-		this.sendEvent(writer, ENDPOINT_EVENT_TYPE, this.baseUrl + this.messageEndpoint + "?sessionId=" + sessionId);
+		this.sendEvent(writer, ENDPOINT_EVENT_TYPE, buildEndpointUrl(sessionId));
+	}
+
+	/**
+	 * Constructs the full message endpoint URL by combining the base URL, message path,
+	 * and the required session_id query parameter.
+	 * @param sessionId the unique session identifier
+	 * @return the fully qualified endpoint URL as a string
+	 */
+	private String buildEndpointUrl(String sessionId) {
+		return UriBuilder.from(this.baseUrl).path(this.messageEndpoint).queryParam(SESSION_ID, sessionId).buildString();
 	}
 
 	/**

mcp-core/src/main/java/io/modelcontextprotocol/util/UriBuilder.java

@@ -0,0 +1,343 @@
+/*
+ * Copyright 2025 - 2025 the original author or authors.
+ */
+
+package io.modelcontextprotocol.util;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringJoiner;
+
+/**
+ * Building URL strings from a base URL, an additional path segment, and optional query
+ * parameters.
+ * <p>
+ * Example usage:
+ * </p>
+ * <pre>{@code
+ * String url = UriBuilder.build(
+ *     "https://api.example.com",
+ *     "/v1/messages",
+ *     Map.of("session_id", "abc123", "format", "json")
+ * );
+ * // Result: https://api.example.com/v1/messages?session_id=abc123&format=json
+ * }</pre>
+ *
+ * @author lance
+ */
+public final class UriBuilder {
+
+	private final String scheme;
+
+	private final String host;
+
+	private final int port;
+
+	private final List<String> pathSegments;
+
+	private final Map<String, List<String>> queryParams;
+
+	private final String fragment;
+
+	private UriBuilder(Builder builder) {
+		this.scheme = builder.scheme;
+		this.host = builder.host;
+		this.port = builder.port;
+		this.pathSegments = List.copyOf(builder.pathSegments);
+		this.queryParams = deepCopy(builder.queryParams);
+		this.fragment = builder.fragment;
+	}
+
+	/**
+	 * Parses a full URL string and returns a mutable {@link Builder} pre-filled with its
+	 * components.
+	 */
+	public static Builder from(String url) {
+		if (url == null || url.isBlank()) {
+			throw new IllegalArgumentException("URL must not be null or blank");
+		}
+
+		URI uri;
+		try {
+			uri = new URI(url.trim());
+		}
+		catch (URISyntaxException e) {
+			throw new IllegalArgumentException("Invalid URL: " + url, e);
+		}
+
+		Builder builder = new Builder().scheme(uri.getScheme()).host(uri.getHost()).port(normalizePort(uri));
+
+		addPathSegments(builder, uri.getRawPath());
+		addQuery(uri.getRawQuery(), builder);
+		addFragment(builder, uri.getRawFragment());
+		return builder;
+	}
+
+	/**
+	 * Returns default port (80 for http, 443 for https) if not explicitly set
+	 */
+	private static int normalizePort(URI uri) {
+		int port = uri.getPort();
+		if (port != -1) {
+			return port;
+		}
+		String scheme = uri.getScheme();
+		return "https".equalsIgnoreCase(scheme) ? 443 : 80;
+	}
+
+	/**
+	 * Splits raw path and adds non-empty segments (filters out "//")
+	 */
+	private static void addPathSegments(Builder builder, String rawPath) {
+		if (rawPath == null || rawPath.isEmpty() || "/".equals(rawPath)) {
+			return;
+		}
+		for (String segment : rawPath.split("/")) {
+			if (!segment.isEmpty()) {
+				builder.pathSegment(segment);
+			}
+		}
+	}
+
+	/**
+	 * Parses raw query string into key → list of values
+	 */
+	private static void addQuery(String rawQuery, Builder builder) {
+		if (rawQuery == null || rawQuery.isEmpty()) {
+			return;
+		}
+		for (String pair : rawQuery.split("&")) {
+			if (pair.isEmpty()) {
+				continue;
+			}
+
+			String[] kv = pair.split("=", 2);
+			String key = kv[0];
+			String value = kv.length > 1 ? kv[1] : null;
+
+			builder.queryParam(key, value);
+		}
+	}
+
+	/**
+	 * Sets fragment if present
+	 */
+	private static void addFragment(Builder builder, String rawFragment) {
+		if (rawFragment != null && !rawFragment.isEmpty()) {
+			builder.fragment(rawFragment);
+		}
+	}
+
+	@Override
+	public String toString() {
+		return buildString();
+	}
+
+	/**
+	 * Builds the final URL string with proper encoding and formatting
+	 */
+	public String buildString() {
+		StringBuilder sb = new StringBuilder();
+		appendScheme(sb);
+		appendAuthority(sb);
+		appendPath(sb);
+		appendQuery(sb);
+		appendFragment(sb);
+		return sb.toString();
+	}
+
+	private void appendScheme(StringBuilder sb) {
+		if (scheme != null) {
+			sb.append(scheme).append("://");
+		}
+	}
+
+	private void appendAuthority(StringBuilder sb) {
+		if (host == null) {
+			return;
+		}
+
+		sb.append(host);
+		if (shouldAppendPort()) {
+			sb.append(':').append(port);
+		}
+	}
+
+	/**
+	 * Omit port if it matches the default for the scheme
+	 */
+	private boolean shouldAppendPort() {
+		if (port <= 0) {
+			return false;
+		}
+		if ("http".equalsIgnoreCase(scheme) && port == 80) {
+			return false;
+		}
+		return !"https".equalsIgnoreCase(scheme) || port != 443;
+	}
+
+	private void appendPath(StringBuilder sb) {
+		if (!pathSegments.isEmpty()) {
+			for (String seg : pathSegments) {
+				sb.append('/').append(encode(seg));
+			}
+		}
+	}
+
+	/**
+	 * Appends URL query parameters to the given.
+	 */
+	private void appendQuery(StringBuilder sb) {
+		if (queryParams.isEmpty()) {
+			return;
+		}
+
+		StringJoiner joiner = new StringJoiner("&");
+		for (Map.Entry<String, List<String>> entry : queryParams.entrySet()) {
+			String encodedKey = encode(entry.getKey());
+			List<String> values = entry.getValue();
+
+			// key only (no value)
+			if (values == null || values.isEmpty()) {
+				joiner.add(encodedKey);
+				continue;
+			}
+
+			for (String value : values) {
+				if (value == null) {
+					joiner.add(encodedKey);
+				}
+				else {
+					joiner.add(encodedKey + "=" + encode(value));
+				}
+			}
+		}
+
+		sb.append('?').append(joiner);
+	}
+
+	private void appendFragment(StringBuilder sb) {
+		if (fragment != null) {
+			sb.append('#').append(encode(fragment));
+		}
+	}
+
+	/**
+	 * Percent-encodes using UTF-8, keeps '/' unencoded in path
+	 */
+	private static String encode(String s) {
+		if (s == null) {
+			return "";
+		}
+		return URLEncoder.encode(s, StandardCharsets.UTF_8).replace("\\+", "%20").replace("%2F", "/");
+	}
+
+	/**
+	 * Deep copy of query parameter map (defensive)
+	 */
+	private static Map<String, List<String>> deepCopy(Map<String, List<String>> src) {
+		Map<String, List<String>> copy = new LinkedHashMap<>();
+		src.forEach((k, v) -> copy.put(k, new ArrayList<>(v)));
+		return copy;
+	}
+
+	/**
+	 * Mutable builder for constructing {@link UriBuilder} instances
+	 */
+	public static class Builder {
+
+		private String scheme;
+
+		private String host;
+
+		private int port = -1;
+
+		private final List<String> pathSegments = new ArrayList<>();
+
+		private final Map<String, List<String>> queryParams = new LinkedHashMap<>();
+
+		private String fragment;
+
+		private Builder() {
+		}
+
+		public Builder scheme(String scheme) {
+			this.scheme = scheme;
+			return this;
+		}
+
+		public Builder host(String host) {
+			this.host = host == null ? null : host.toLowerCase();
+			return this;
+		}
+
+		public Builder port(int port) {
+			this.port = port;
+			return this;
+		}
+
+		/**
+		 * Adds a single decoded path segment
+		 */
+		public void pathSegment(String segment) {
+			if (segment != null && !segment.isEmpty()) {
+				pathSegments.add(segment);
+			}
+		}
+
+		/**
+		 * Adds multiple segments from a path string (ignores empty parts)
+		 */
+		public Builder path(String path) {
+			if (path != null) {
+				for (String seg : path.split("/")) {
+					if (!seg.isEmpty()) {
+						pathSegments.add(seg);
+					}
+				}
+			}
+			return this;
+		}
+
+		/**
+		 * Adds one or more values for a query parameter (null value = no "=")
+		 */
+		public Builder queryParam(String key, String... values) {
+			if (key != null) {
+				List<String> list = queryParams.computeIfAbsent(key, k -> new ArrayList<>());
+				if (values != null) {
+					for (String v : values) {
+						if (v != null) {
+							list.add(v);
+						}
+					}
+				}
+				else {
+					list.add(null);
+				}
+			}
+
+			return this;
+		}
+
+		public void fragment(String fragment) {
+			this.fragment = fragment;
+		}
+
+		public UriBuilder build() {
+			return new UriBuilder(this);
+		}
+
+		public String buildString() {
+			return new UriBuilder(this).buildString();
+		}
+
+	}
+
+}