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

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,
@@ -17202,7 +17231,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 +17692,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 +22973,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 +24475,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 })] };