@mastra/mcp 2.5.0 → 2.6.0-alpha.0

package/dist/index.js

@@ -12952,6 +12952,89 @@ const SCHEMA_MAP_KEYWORDS$1 = /* @__PURE__ */ new Set([
 const MAX_JSON_SCHEMA_NODES = 1e4;
 var Unconvertible = class extends Error {};
 /**
+* Bounds the work a validator or type generator can be asked to do for an untrusted schema.
+* Only schema-bearing keywords are walked, so deeply nested annotation data such as `default`
+* or `examples` does not count. The counted nodes are returned so callers can also budget
+* across a whole catalogue rather than one schema at a time.
+*
+* The keyword lists are intentionally wider than the conversion sets above: this walk has to
+* reach every position that can carry validation rules, including `dependencies`,
+* `prefixItems`, and `contentSchema`.
+*/
+function jsonSchemaComplexity(schema) {
+	const seen = /* @__PURE__ */ new Set();
+	let nodes = 0;
+	const stack = [{
+		value: schema,
+		depth: 0
+	}];
+	const schemaMapKeywords = [
+		"$defs",
+		"definitions",
+		"properties",
+		"patternProperties",
+		"dependentSchemas",
+		"dependencies"
+	];
+	const schemaArrayKeywords = [
+		"prefixItems",
+		"allOf",
+		"anyOf",
+		"oneOf",
+		"items"
+	];
+	const schemaKeywords = [
+		"additionalProperties",
+		"unevaluatedProperties",
+		"additionalItems",
+		"unevaluatedItems",
+		"items",
+		"contains",
+		"propertyNames",
+		"not",
+		"if",
+		"then",
+		"else",
+		"contentSchema"
+	];
+	while (stack.length > 0) {
+		const { value, depth } = stack.pop();
+		if (value === null || typeof value !== "object" || Array.isArray(value) || seen.has(value)) continue;
+		seen.add(value);
+		nodes += 1;
+		if (depth > 128) return {
+			error: `JSON Schema exceeds the maximum depth of 128`,
+			limit: "depth",
+			nodes
+		};
+		if (nodes > 1e4) return {
+			error: `JSON Schema exceeds the maximum node count of ${MAX_JSON_SCHEMA_NODES}`,
+			limit: "nodes",
+			nodes
+		};
+		const record = value;
+		for (const keyword of schemaMapKeywords) {
+			const schemas = record[keyword];
+			if (schemas && typeof schemas === "object" && !Array.isArray(schemas)) for (const child of Object.values(schemas)) stack.push({
+				value: child,
+				depth: depth + 1
+			});
+		}
+		for (const keyword of schemaArrayKeywords) {
+			const schemas = record[keyword];
+			if (Array.isArray(schemas)) for (const child of schemas) stack.push({
+				value: child,
+				depth: depth + 1
+			});
+		}
+		for (const keyword of schemaKeywords) if (record[keyword] !== void 0) stack.push({
+			value: record[keyword],
+			depth: depth + 1
+		});
+	}
+	return { nodes };
+}
+/**
 * Converts a 2019-09 schema (e.g. from zod v3) into 2020-12 form. Tuples are the
 * only structural difference handled: array-form `items` becomes `prefixItems`,
 * and `additionalItems` becomes `items`.
@@ -15142,75 +15225,6 @@ async function fetchFollowingAllowedRedirects(fetchImpl, url, init, allowedHosts
 //#endregion
 //#region src/client/client.ts
 const DEFAULT_SERVER_CONNECT_TIMEOUT_MSEC = 3e3;
-/**
-* Bounds the work a validator can be asked to do for an untrusted tool catalogue.
-* Only schema-bearing keywords are walked, so deeply nested annotation data such as
-* `default` or `examples` does not count.
-*/
-function getJsonSchemaComplexityError(schema) {
-	const seen = /* @__PURE__ */ new Set();
-	let nodes = 0;
-	const stack = [{
-		value: schema,
-		depth: 0
-	}];
-	const schemaMapKeywords = [
-		"$defs",
-		"definitions",
-		"properties",
-		"patternProperties",
-		"dependentSchemas",
-		"dependencies"
-	];
-	const schemaArrayKeywords = [
-		"prefixItems",
-		"allOf",
-		"anyOf",
-		"oneOf",
-		"items"
-	];
-	const schemaKeywords = [
-		"additionalProperties",
-		"unevaluatedProperties",
-		"additionalItems",
-		"unevaluatedItems",
-		"items",
-		"contains",
-		"propertyNames",
-		"not",
-		"if",
-		"then",
-		"else",
-		"contentSchema"
-	];
-	while (stack.length > 0) {
-		const { value, depth } = stack.pop();
-		if (value === null || typeof value !== "object" || Array.isArray(value) || seen.has(value)) continue;
-		seen.add(value);
-		nodes += 1;
-		if (depth > 128) return `JSON Schema exceeds the maximum depth of 128`;
-		if (nodes > 1e4) return `JSON Schema exceeds the maximum node count of ${MAX_JSON_SCHEMA_NODES}`;
-		const record = value;
-		for (const keyword of schemaMapKeywords) {
-			const schemas = record[keyword];
-			if (schemas && typeof schemas === "object" && !Array.isArray(schemas)) for (const child of Object.values(schemas)) stack.push({
-				value: child,
-				depth: depth + 1
-			});
-		}
-		for (const keyword of schemaArrayKeywords) {
-			const schemas = record[keyword];
-			if (Array.isArray(schemas)) for (const child of schemas) stack.push({
-				value: child,
-				depth: depth + 1
-			});
-		}
-		for (const keyword of schemaKeywords) if (record[keyword] !== void 0) stack.push({
-			value: record[keyword],
-			depth: depth + 1
-		});
-	}
-}
 const SUPPORTED_DIALECTS = /* @__PURE__ */ new Set([
 	JSON_SCHEMA_2020_12,
 	`${JSON_SCHEMA_2020_12}#`,
@@ -15416,6 +15430,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 	name;
 	client;
 	timeout;
+	processHooks;
 	logHandler;
 	serverLogLevel;
 	enableProgressTracking;
@@ -15452,12 +15467,13 @@ var InternalMastraMCPClient = class extends MastraBase {
 	/**
 	* @internal
 	*/
-	constructor({ name, version = "1.0.0", clientInfo, server, timeout = DEFAULT_REQUEST_TIMEOUT_MSEC, webhook }) {
+	constructor({ name, version = "1.0.0", clientInfo, server, timeout = DEFAULT_REQUEST_TIMEOUT_MSEC, registerProcessHooks = true, webhook }) {
 		super({ name: "MastraMCPClient" });
 		this.webhook = webhook;
 		loadInputSchemaMetaValidator();
 		this.name = name;
 		this.timeout = timeout;
+		this.processHooks = registerProcessHooks;
 		this.logHandler = server.logger;
 		this.serverLogLevel = server.enableServerLogs ?? true ? server.serverLogLevel ?? DEFAULT_SERVER_LOG_LEVEL : void 0;
 		this.serverConfig = server;
@@ -15800,7 +15816,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 				reject(e);
 			}
 		});
-		this.registerProcessHooks();
+		if (this.processHooks) this.registerProcessHooks();
 		return this.isConnected;
 	}
 	/**
@@ -16343,7 +16359,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 	buildToolFromListEntry(tool, serverMeta) {
 		const rawInputSchema = tool.inputSchema;
 		const inputSchema = rawInputSchema && typeof rawInputSchema === "object" && "jsonSchema" in rawInputSchema ? rawInputSchema.jsonSchema : rawInputSchema;
-		const inputSchemaError = getJsonSchemaComplexityError(inputSchema) ?? getInputSchemaError(inputSchema);
+		const inputSchemaError = jsonSchemaComplexity(inputSchema).error ?? getInputSchemaError(inputSchema);
 		if (inputSchemaError) {
 			const details = {
 				serverName: this.name,
@@ -16385,7 +16401,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 				...annotations ? { annotations } : {}
 			} } : {};
 			const outputSchema = tool.outputSchema ? withDefaultDialect("jsonSchema" in tool.outputSchema ? tool.outputSchema.jsonSchema : tool.outputSchema) : void 0;
-			const outputSchemaComplexityError = outputSchema ? getJsonSchemaComplexityError(outputSchema) : void 0;
+			const outputSchemaComplexityError = outputSchema ? jsonSchemaComplexity(outputSchema).error : void 0;
 			let outputValidationSchema;
 			const getOutputValidationSchema = async () => {
 				if (!outputSchema) return void 0;
@@ -17327,6 +17343,10 @@ var MCPClientServerProxy = class extends MCPServerBase {
 //#endregion
 //#region src/client/configuration.ts
 const mcpClientInstances = /* @__PURE__ */ new Map();
+/** Reads the shared cache without promising the snapshot shape it was created with. */
+function cachedClient(id) {
+	return mcpClientInstances.get(id);
+}
 const TOOL_DISCOVERY_MAX_ATTEMPTS = 2;
 const LOOPBACK_IPV4 = /^127\.(?:\d{1,3})\.(?:\d{1,3})\.(?:\d{1,3})$/;
 function isLoopbackHostname(hostname) {
@@ -17359,10 +17379,12 @@ function isLoopbackHostname(hostname) {
 * if packaged docs are unavailable.
 */
 var MCPClient = class extends MastraBase {
+	typegen;
 	serverConfigs = {};
 	id;
 	defaultTimeout;
 	defaultClientInfo;
+	registerProcessHooks;
 	webhook;
 	mcpClientsById = /* @__PURE__ */ new Map();
 	disconnectPromise = null;
@@ -17407,6 +17429,7 @@ var MCPClient = class extends MastraBase {
 		super({ name: "MCPClient" });
 		this.defaultTimeout = args.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
 		this.defaultClientInfo = args.clientInfo && { ...args.clientInfo };
+		this.registerProcessHooks = args.registerProcessHooks ?? true;
 		this.serverConfigs = args.servers;
 		this.webhook = args.webhook && {
 			options: { ...args.webhook },
@@ -17415,16 +17438,13 @@ var MCPClient = class extends MastraBase {
 		this.id = args.id ?? this.makeId();
 		if (args.id) {
 			this.id = args.id;
-			const cached = mcpClientInstances.get(this.id);
-			if (cached && (!equal(cached.serverConfigs, args.servers) || !equal(cached.defaultClientInfo, args.clientInfo))) {
-				const existingInstance = mcpClientInstances.get(this.id);
-				if (existingInstance) {
-					existingInstance.disconnect();
-					mcpClientInstances.delete(this.id);
-				}
+			const cached = cachedClient(this.id);
+			if (cached && (!equal(cached.serverConfigs, args.servers) || !equal(cached.defaultClientInfo, args.clientInfo) || cached.registerProcessHooks !== this.registerProcessHooks || cached.typegen?.outFile !== args.typegen?.outFile)) {
+				cached.disconnect();
+				mcpClientInstances.delete(this.id);
 			}
 		} else this.id = this.makeId();
-		const existingInstance = mcpClientInstances.get(this.id);
+		const existingInstance = cachedClient(this.id);
 		if (existingInstance) {
 			if (!args.id) throw new Error(`MCPClient was initialized multiple times with the same configuration options.
 
@@ -17437,6 +17457,11 @@ To fix this you have three different options:
 `);
 			return existingInstance;
 		}
+		const { typegen } = args;
+		if (typegen !== void 0) {
+			if (!typegen || typeof typegen.outFile !== "string" || !typegen.outFile.trim() || typegen.outFile.includes("\0")) throw new Error("typegen.outFile must be a nonempty file path");
+			this.typegen = Object.freeze({ outFile: typegen.outFile });
+		}
 		mcpClientInstances.set(this.id, this);
 		this.addToInstanceCache();
 		return this;
@@ -17900,9 +17925,10 @@ onListChanged: async (serverName, handler) => {
 		if (!mcpClientInstances.has(this.id)) mcpClientInstances.set(this.id, this);
 	}
 	makeId() {
-		const text = JSON.stringify(this.defaultClientInfo === void 0 ? this.serverConfigs : {
+		const text = JSON.stringify(this.defaultClientInfo === void 0 && this.registerProcessHooks ? this.serverConfigs : {
 			servers: this.serverConfigs,
-			clientInfo: this.defaultClientInfo
+			...this.defaultClientInfo === void 0 ? {} : { clientInfo: this.defaultClientInfo },
+			...this.registerProcessHooks ? {} : { registerProcessHooks: false }
 		}).normalize("NFKC");
 		return createHash("sha256").update("MCPClient").update(text).digest("hex");
 	}
@@ -18143,24 +18169,6 @@ onListChanged: async (serverName, handler) => {
 	async listTools() {
 		return (await this.listToolsWithErrors()).tools;
 	}
-	/**
-	* Retrieves all tools from all configured servers with namespaced names,
-	* along with any per-server errors.
-	*
-	* Like listTools(), but also returns errors for servers that failed to connect
-	* or list tools. This allows callers to report specific failure reasons per server.
-	*
-	* @returns Object with successful `tools`, legacy string `errors`, and structured `errorDetails`.
-	* Transient connection failures are retried once after reconnecting the affected server.
-	*
-	* @example
-	* ```typescript
-	* const { tools, errors, errorDetails } = await mcp.listToolsWithErrors();
-	* for (const [name, err] of Object.entries(errors)) {
-	*   console.error(`Server ${name} failed: ${err}`, errorDetails[name]);
-	* }
-	* ```
-	*/
 	async listToolsWithErrors(options) {
 		this.addToInstanceCache();
 		const connectedTools = {};
@@ -18216,23 +18224,6 @@ onListChanged: async (serverName, handler) => {
 	async listToolsets() {
 		return (await this.listToolsetsWithErrors()).toolsets;
 	}
-	/**
-	* Returns toolsets organized by server name, along with any per-server errors.
-	*
-	* Like listToolsets(), but also returns errors for servers that failed to connect
-	* or list tools. This allows callers to report specific failure reasons per server.
-	*
-	* @returns Object with successful `toolsets`, legacy string `errors`, and structured `errorDetails`.
-	* Transient connection failures are retried once after reconnecting the affected server.
-	*
-	* @example
-	* ```typescript
-	* const { toolsets, errors, errorDetails } = await mcp.listToolsetsWithErrors();
-	* for (const [name, err] of Object.entries(errors)) {
-	*   console.error(`Server ${name} failed: ${err}`, errorDetails[name]);
-	* }
-	* ```
-	*/
 	async listToolsetsWithErrors(options) {
 		this.addToInstanceCache();
 		const connectedToolsets = {};
@@ -18563,6 +18554,7 @@ onListChanged: async (serverName, handler) => {
 			name,
 			server: config,
 			timeout: config.timeout ?? this.defaultTimeout,
+			registerProcessHooks: this.registerProcessHooks,
 			clientInfo: {
 				name: config.clientInfo?.name ?? this.defaultClientInfo?.name,
 				version: config.clientInfo?.version ?? this.defaultClientInfo?.version
@@ -20243,6 +20235,7 @@ var MCPServer = class extends MCPServerBase {
 	eventsOptions;
 	eventsInspector;
 	webhooks;
+	legacy;
 	httpHandler;
 	nodeHandler;
 	stdioHandle;
@@ -20258,6 +20251,7 @@ var MCPServer = class extends MCPServerBase {
 		this.loadAppResources(config.appResources);
 		this.requestStateCodec = this.createRequestStateCodec(config.requestState);
 		this.eventsOptions = config.eventsOptions ?? {};
+		this.legacy = config.legacy ?? "reject";
 		const webhook = this.eventsOptions.webhook;
 		this.eventRegistry = new ServerEventRegistry(config.events, { webhook: webhook !== void 0 });
 		if (webhook && this.eventRegistry.size > 0) this.webhooks = new WebhookDispatcher({
@@ -20787,7 +20781,7 @@ var MCPServer = class extends MCPServerBase {
 						resumeSchema: execution.resumeSchema
 					});
 				}
-				const result = this.toCallToolResult(name, tool, execution.output);
+				const result = server.projectCallToolResult(this.toCallToolResult(name, tool, execution.output), this.toolInfo(name, tool).outputSchema);
 				this.logger.info(`Tool '${name}' finished in ${Date.now() - startedAt}ms.`);
 				return result;
 			} catch (error) {
@@ -21053,7 +21047,7 @@ var MCPServer = class extends MCPServerBase {
 	getNodeHandler() {
 		if (!this.nodeHandler) {
 			this.httpHandler = createMcpHandler(() => this.createServerInstance(), {
-				legacy: "reject",
+				legacy: this.legacy,
 				onerror: (error) => this.logger.error("MCP handler error", { error: error.toString() })
 			});
 			this.nodeHandler = toNodeHandler(this.httpHandler, { onerror: (error) => this.logger.error("MCP Node handler adapter error", { error: error.toString() }) });
@@ -21073,7 +21067,8 @@ var MCPServer = class extends MCPServerBase {
 	}
 	/**
 	* Handles one Streamable HTTP request at `httpPath`. Every request is
-	* self-contained; requests without a 2026-07-28 envelope are rejected.
+	* self-contained; requests without a 2026-07-28 envelope are rejected unless
+	* `legacy: 'stateless'` is configured.
 	*/
 	async startHTTP({ url, httpPath, req, res, options }) {
 		if (url.pathname !== httpPath) {