@mastra/mcp 2.9.0-alpha.0 → 2.9.0-alpha.2

package/dist/index.js

@@ -14385,6 +14385,35 @@ function isReconnectableMCPError(error) {
 	const errorMessage = error.message.toLowerCase();
 	return errorMessage.includes("not connected") || errorMessage.includes("http 400") || errorMessage.includes("http 401") || errorMessage.includes("http 403") || errorMessage.includes("http 404") || errorMessage.includes("econnrefused") || errorMessage.includes("fetch failed") || errorMessage.includes("connection refused") || errorMessage.includes("connection closed") || errorMessage.includes("typeerror: terminated");
 }
+const CONNECTION_NOT_ESTABLISHED_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+const REJECTED_BEFORE_DISPATCH_STATUSES = /* @__PURE__ */ new Set([
+	400,
+	401,
+	403,
+	404
+]);
+/**
+* Whether a reconnectable failure proves the request never reached the server's
+* handler, so sending it again cannot repeat its effects.
+*
+* A reset socket (`fetch failed` with `UND_ERR_SOCKET`), a cut-off response
+* (`terminated`) or a closed transport (`Connection closed`) can all follow a
+* request the server already received and ran, so they return false.
+*/
+function isUnsentRequestError(error) {
+	if (!isReconnectableMCPError(error)) return false;
+	const { httpStatus, code } = getMCPDiscoveryErrorDetails(error);
+	if (typeof code === "number") return false;
+	if (httpStatus !== void 0) return REJECTED_BEFORE_DISPATCH_STATUSES.has(httpStatus);
+	const message = error.message.toLowerCase();
+	if (message.includes("not connected") || message.includes("econnrefused") || message.includes("connection refused") || /\bhttp 40[0134]\b/.test(message)) return true;
+	return typeof code === "string" && CONNECTION_NOT_ESTABLISHED_CODES.has(code);
+}
 const GATEWAY_UNAVAILABLE_STATUSES = /* @__PURE__ */ new Set([
 	502,
 	503,
@@ -15815,6 +15844,16 @@ function shouldDetachPersistentTransportRequest(init) {
 		return false;
 	}
 }
+/** Whether a request body is a single JSON-RPC response: the client's reply to a server request. */
+function isJsonRpcResponseBody(body) {
+	if (typeof body !== "string") return false;
+	try {
+		const message = JSON.parse(body);
+		return typeof message === "object" && message !== null && !Array.isArray(message) && !("method" in message) && "id" in message && ("result" in message || "error" in message);
+	} catch {
+		return false;
+	}
+}
 const TASK_WAIT_ERROR_IDS = {
 	timeout: "MCP_CLIENT_TOOL_TASK_TIMEOUT",
 	expired: "MCP_CLIENT_TOOL_TASK_EXPIRED",
@@ -16043,6 +16082,19 @@ var InternalMastraMCPClient = class extends MastraBase {
 	clientConnectionOnClose;
 	_authState;
 	operationContextStore = new AsyncLocalStorage();
+	/**
+	* The requestContext of the tool call whose execution opened the connection. Only the
+	* transport's fetch reads it, so the handshake and the streams the connection keeps open are
+	* sent as that call. Messages arriving on those streams are delivered outside it, so server logs
+	* are not labelled with it and requests their handlers send are not sent as that call.
+	*/
+	connectionContextStore = new AsyncLocalStorage();
+	/**
+	* The connection context of the transport a server message arrived on, as it was when that
+	* transport was created, set while the message is delivered. The transport's fetch reads it only for the client's replies to server requests,
+	* which belong to the connection rather than to the handler that produced them.
+	*/
+	replyContextStore = new AsyncLocalStorage();
 	exitHookUnsubscribe;
 	sigTermHandler;
 	sigHupHandler;
@@ -16235,7 +16287,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 		if (allowedHosts !== void 0) assertHostAllowed(url, allowedHosts);
 		const policyUserFetch = userFetch && allowedHosts !== void 0 ? wrapFetchWithHostPolicy(userFetch, allowedHosts) : void 0;
 		const fetch = (requestUrl, init) => {
-			const requestContext = this.operationContextStore.getStore() ?? null;
+			const requestContext = this.fetchRequestContext(init);
 			const executeFetch = () => {
 				if (allowedHosts === void 0) return userFetch ? userFetch(requestUrl, init, requestContext) : globalThis.fetch(requestUrl, init);
 				if (policyUserFetch) return policyUserFetch(requestUrl, init, requestContext);
@@ -16250,6 +16302,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 			fetch
 		});
 		observeEventStreamRequests(transport, this.noteEventStreamSent);
+		this.deliverOutsideConnectionContext(transport);
 		this.connectingTransport = transport;
 		try {
 			this.assertSameLifecycle(generation);
@@ -16271,6 +16324,59 @@ var InternalMastraMCPClient = class extends MastraBase {
 		}
 	}
 	/**
+	* Connects as a tool call: the handshake and the streams the connection keeps open reach the
+	* transport's fetch with the call's requestContext, through the connection context. Any enclosing
+	* operation scope is exited first. It would take priority in fetch, and the new streams and stdio
+	* child would deliver every later server message in it.
+	*/
+	connectAsCall(requestContext, connect) {
+		return this.operationContextStore.exit(() => this.connectionContextStore.run(requestContext, connect));
+	}
+	/**
+	* The requestContext the transport's fetch passes on for an outgoing request. An operation scope
+	* owns its requests, even when its requestContext is null. Outside one, the handshake and the
+	* streams the connection keeps open use the connection context, and a reply to a server request
+	* uses the context of the connection that delivered the request.
+	*/
+	fetchRequestContext(init) {
+		const operationContext = this.operationContextStore.getStore();
+		if (operationContext !== void 0) return operationContext;
+		const connectionContext = this.connectionContextStore.getStore();
+		if (connectionContext !== void 0) return connectionContext;
+		const replyContext = this.replyContextStore.getStore();
+		if (replyContext !== void 0 && isJsonRpcResponseBody(init?.body)) return replyContext;
+		return null;
+	}
+	/**
+	* Delivers every message the server sends outside the connection context, from the handshake on.
+	* A server log, notification or request arriving on a stream the opening call started belongs to
+	* no call, so a request its handler sends must not be sent as that call. The client's reply to a
+	* server request still is, through `replyContextStore`.
+	*
+	* The reply context is the connection context this transport was created in, captured once. Read
+	* at delivery time, it would carry over to a connection that a handler of an older connection's
+	* message opens, such as a `reconnectServer()` from a server log callback.
+	*
+	* The SDK assigns `onmessage` during `connect()` and swaps it while probing the server, so every
+	* assignment is wrapped. A handler that wraps an already wrapped one (`interceptTaskResults`, or
+	* the probe restoring its saved handler) runs with the same reply context.
+	*/
+	deliverOutsideConnectionContext(transport) {
+		const replyContext = this.connectionContextStore.getStore() ?? null;
+		let deliver;
+		Object.defineProperty(transport, "onmessage", {
+			configurable: true,
+			enumerable: true,
+			get: () => deliver,
+			set: (handler) => {
+				deliver = handler && ((message, extra) => {
+					const dispatch = () => handler.call(transport, message, extra);
+					this.connectionContextStore.exit(() => this.replyContextStore.run(replyContext, dispatch));
+				});
+			}
+		});
+	}
+	/**
 	* Detaches whatever transport is still attached to the underlying SDK Client.
 	*
 	* The SDK assigns its internal `_transport` before `transport.start()` and never
@@ -16608,7 +16714,8 @@ var InternalMastraMCPClient = class extends MastraBase {
 				this.serverImplementation = void 0;
 			}
 			this.assertSameLifecycle(generation);
-			await this.connect(generation);
+			const callContext = this.operationContextStore.getStore();
+			await (callContext === void 0 ? this.connect(generation) : this.connectAsCall(callContext, () => this.connect(generation)));
 			this.log("debug", "Successfully reconnected to MCP server");
 		})();
 		this.reconnectPromise = reconnectPromise;
@@ -17101,8 +17208,8 @@ var InternalMastraMCPClient = class extends MastraBase {
 				},
 				...tool.outputSchema ? { toModelOutput: createStructuredToolToModelOutput() } : {},
 				execute: async (input, context) => {
-					if (serverMeta.connectFirst) await this.connect();
 					const operationContext = context?.requestContext ?? null;
+					if (serverMeta.connectFirst) await this.connectAsCall(operationContext, () => this.connect());
 					return this.operationContextStore.run(operationContext, async () => {
 						const suspendHost = context?.agent ?? context?.workflow;
 						const toolCallSpan = context?.tracingContext?.currentSpan;
@@ -17202,7 +17309,26 @@ var InternalMastraMCPClient = class extends MastraBase {
 						try {
 							return await executeToolCall();
 						} catch (e) {
-							if (!(e instanceof MastraError && (e.id === "MCP_CLIENT_TOOL_EXECUTION_FAILED" || e.id.startsWith("MCP_CLIENT_TOOL_TASK_"))) && isReconnectableMCPError(e)) {
+							const isToolExecutionError = e instanceof MastraError && (e.id === "MCP_CLIENT_TOOL_EXECUTION_FAILED" || e.id.startsWith("MCP_CLIENT_TOOL_TASK_"));
+							if (!isToolExecutionError && isReconnectableMCPError(e) && !isUnsentRequestError(e)) {
+								if (annotations?.readOnlyHint === true || annotations?.idempotentHint === true) {
+									this.log("debug", `Retrying replay-safe tool ${tool.name} after a transport error`, { error: errorKind(e) });
+									if (this.transport !== failedTransport || this.reconnectPromise) await this.reconnectAfterTransportFailure(failedTransport, lifecycleGeneration);
+									return await executeToolCall();
+								}
+								this.log("error", `Lost the connection during tool ${tool.name}; it may have run`, { error: errorKind(e) });
+								throw new MastraError({
+									id: "MCP_CLIENT_TOOL_CALL_OUTCOME_UNKNOWN",
+									domain: ErrorDomain.MCP,
+									category: ErrorCategory.THIRD_PARTY,
+									text: `The connection to MCP server "${this.name}" failed before tool "${tool.name}" returned a result. The tool may have run on the server, so it was not called again.`,
+									details: {
+										toolName: tool.name,
+										serverName: this.name
+									}
+								}, e);
+							}
+							if (!isToolExecutionError && isReconnectableMCPError(e)) {
 								this.log("debug", `Transport error detected for tool ${tool.name}, attempting reconnection...`, { error: errorKind(e) });
 								try {
 									await this.reconnectAfterTransportFailure(failedTransport, lifecycleGeneration);
@@ -17644,12 +17770,12 @@ async function createOAuthCallbackServer(options) {
 		},
 		close() {
 			settle({ error: /* @__PURE__ */ new Error("OAuth callback server closed before receiving an authorization code") });
-			server.closeIdleConnections();
 			return new Promise((resolve, reject) => {
 				server.close((error) => {
 					if (error && error.code !== "ERR_SERVER_NOT_RUNNING") reject(error);
 					else resolve();
 				});
+				server.closeAllConnections();
 			});
 		}
 	};
@@ -22925,6 +23051,136 @@ function stepAt(workflow, path) {
 	}
 	return step;
 }
+// src/server/uri-template.ts
+/**
+* Whether `uri` is an RFC 6570 expansion of `template`. Decides membership only,
+* without extracting variables.
+*
+* The SDK's `UriTemplate.match` is a backtracking regex that takes minutes on a
+* few KB of client URI when variables are adjacent (`x://{a}-{b}-{c}-{d}`); this
+* walks the URI once per template segment instead.
+*
+* Plain `{x}` and `{+x}` must be non-empty, since an empty path segment never
+* names a resource. Outside `{+x}` and `{#x}`, values must be percent-encoded:
+* an ASCII reserved character other than `,` ends the value. Raw non-ASCII
+* characters are accepted because clients often send them unencoded.
+*/
+function matchesUriTemplate(template, uri) {
+	return advance(uri, /* @__PURE__ */ new Set([0]), parse(template)).has(uri.length);
+}
+const encoded = (char) => /[\w\-.~,]/.test(char) || char.charCodeAt(0) > 127;
+const anything = () => true;
+const literal = (text) => ({
+	kind: "literal",
+	text
+});
+const run = (allowed, min = 0) => ({
+	kind: "run",
+	allowed,
+	min
+});
+const optional = (...segments) => ({
+	kind: "optional",
+	segments
+});
+const repeat = (...segments) => ({
+	kind: "repeat",
+	segments
+});
+const choice = (options) => ({
+	kind: "choice",
+	options
+});
+function parse(template) {
+	const segments = [];
+	let i = 0;
+	while (i < template.length) {
+		const open = template.indexOf("{", i);
+		const close = open === -1 ? -1 : template.indexOf("}", open);
+		if (close === -1) {
+			segments.push(literal(template.slice(i)));
+			break;
+		}
+		if (open > i) segments.push(literal(template.slice(i, open)));
+		segments.push(...expression(template.slice(open + 1, close)));
+		i = close + 1;
+	}
+	return segments;
+}
+function expression(body) {
+	const operator = "+#./;?&".includes(body[0] ?? "") ? body[0] : "";
+	const specs = body.slice(operator.length).split(",").map((spec) => ({
+		name: spec.replace(/[*]|:\d*$/g, "").trim(),
+		exploded: spec.includes("*")
+	})).filter((spec) => spec.name);
+	switch (operator) {
+		case "": return [run(encoded, 1)];
+		case "+": return [run(anything, 1)];
+		case "#": return [optional(literal("#"), run(anything))];
+		case "/": return specs.map(({ exploded }) => exploded ? repeat(literal("/"), run(encoded)) : optional(literal("/"), run(encoded)));
+		case ".": return specs.map(() => optional(literal("."), run(encoded)));
+		case ";": return specs.map(({ name, exploded }) => (exploded ? repeat : optional)(literal(`;${name}`), optional(literal("="), run(encoded))));
+		default: {
+			const pair = ({ name, exploded }, separator) => {
+				const first = [literal(`${separator}${name}=`), run(encoded)];
+				return exploded ? [...first, repeat(literal(`&${name}=`), run(encoded))] : first;
+			};
+			const firstPresent = specs.map((spec, i) => [...pair(spec, operator), ...specs.slice(i + 1).map((later) => optional(...pair(later, "&")))]);
+			return [optional(choice(firstPresent))];
+		}
+	}
+}
+/** Every URI offset reachable after matching `segments` from any offset in `from`. */
+function advance(uri, from, segments) {
+	let positions = from;
+	for (const segment of segments) {
+		if (positions.size === 0) break;
+		positions = step(uri, positions, segment);
+	}
+	return positions;
+}
+function step(uri, positions, segment) {
+	const next = /* @__PURE__ */ new Set();
+	switch (segment.kind) {
+		case "literal":
+			for (const p of positions) if (uri.startsWith(segment.text, p)) next.add(p + segment.text.length);
+			return next;
+		case "choice":
+			for (const option of segment.options) for (const p of advance(uri, positions, option)) next.add(p);
+			return next;
+		case "run": {
+			let end = 0;
+			for (const p of [...positions].sort((a, b) => a - b)) {
+				const covered = p < end && next.has(p);
+				if (segment.min === 0) next.add(p);
+				if (covered) continue;
+				end = p;
+				for (let width = charWidth(uri, end, segment.allowed); width > 0; width = charWidth(uri, end, segment.allowed)) next.add(end += width);
+			}
+			return next;
+		}
+		case "optional":
+			for (const p of positions) next.add(p);
+			for (const p of advance(uri, positions, segment.segments)) next.add(p);
+			return next;
+		case "repeat": {
+			for (const p of positions) next.add(p);
+			let frontier = positions;
+			while (frontier.size > 0) {
+				const reached = [...advance(uri, frontier, segment.segments)].filter((p) => !next.has(p));
+				for (const p of reached) next.add(p);
+				frontier = new Set(reached);
+			}
+			return next;
+		}
+	}
+}
+/** Characters a run consumes at `i`: a whole `%HH` triplet, one allowed character, or none. */
+function charWidth(uri, i, allowed) {
+	if (i >= uri.length) return 0;
+	if (uri[i] === "%") return /^%[0-9A-Fa-f]{2}/.test(uri.slice(i, i + 3)) ? 3 : 0;
+	return allowed(uri[i]) ? 1 : 0;
+}
 // src/server/server.ts
 const EMPTY_OBJECT_SCHEMA = {
 	type: "object",
@@ -24297,10 +24553,24 @@ var MCPServer = class extends MCPServerBase {
 			extra: toToolExecutionContext(ctx, this.name).extra,
 			requestContext
 		}) ?? []];
+		const findResource = async (uri, ctx, requestContext) => {
+			const listed = (await listResources(ctx, requestContext)).find((r) => r.uri === uri);
+			if (listed || !options?.resourceTemplates) return listed;
+			const template = (await options.resourceTemplates({
+				extra: toToolExecutionContext(ctx, this.name).extra,
+				requestContext
+			})).find((t) => matchesUriTemplate(t.uriTemplate, uri));
+			return template && {
+				uri,
+				name: template.name,
+				mimeType: template.mimeType,
+				_meta: template._meta
+			};
+		};
 		this.setTracedHandler(server, "resources/list", async (_request, ctx, trace) => ({ resources: await listResources(ctx, trace.requestContext) }));
 		this.setTracedHandler(server, "resources/read", async (request, ctx, trace) => {
 			const uri = request.params.uri;
-			const resource = (await listResources(ctx, trace.requestContext)).find((r) => r.uri === uri);
+			const resource = await findResource(uri, ctx, trace.requestContext);
 			if (!resource) throw new ProtocolError$1(ProtocolErrorCode$1.InvalidParams, `Resource not found: ${uri}`);
 			const html = this.appResourceHtml.get(uri);
 			if (html !== void 0) return { contents: [this.resourceContents(resource, { text: html })] };