@mastra/mcp 2.4.0 → 2.4.1-alpha.0

package/dist/index.js

@@ -22220,7 +22220,7 @@ require_json_schema_traverse();
 const JSON_SCHEMA_2020_12 = "https://json-schema.org/draft/2020-12/schema";
 const JSON_SCHEMA_2019_09 = /^https?:\/\/json-schema\.org\/draft\/2019-09\/schema#?$/;
 /** Keywords whose value is a subschema (`items` may also be an array of subschemas). */
-const SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+const SCHEMA_KEYWORDS$1 = /* @__PURE__ */ new Set([
 	"items",
 	"additionalItems",
 	"contains",
@@ -22234,13 +22234,13 @@ const SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 	"not"
 ]);
 /** Keywords whose value is an array of subschemas. */
-const SCHEMA_ARRAY_KEYWORDS = /* @__PURE__ */ new Set([
+const SCHEMA_ARRAY_KEYWORDS$1 = /* @__PURE__ */ new Set([
 	"allOf",
 	"anyOf",
 	"oneOf"
 ]);
 /** Keywords whose values map arbitrary names to subschemas. */
-const SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+const SCHEMA_MAP_KEYWORDS$1 = /* @__PURE__ */ new Set([
 	"properties",
 	"patternProperties",
 	"$defs",
@@ -22284,11 +22284,11 @@ function rewrite(schema, depth, budget, isRoot = false) {
 	if ("$recursiveRef" in out || "$recursiveAnchor" in out) throw new Unconvertible();
 	if ("unevaluatedItems" in out || "prefixItems" in out || "contentSchema" in out) throw new Unconvertible();
 	if (typeof out.$ref === "string" && /\/(items\/\d+|additionalItems)(\/|$)/.test(out.$ref)) throw new Unconvertible();
-	for (const [key, child] of Object.entries(out)) if (SCHEMA_KEYWORDS.has(key)) out[key] = Array.isArray(child) ? (checkBudget(depth + 1, budget), child.map((item) => rewrite(item, depth + 2, budget))) : rewrite(child, depth + 1, budget);
-	else if (SCHEMA_ARRAY_KEYWORDS.has(key) && Array.isArray(child)) {
+	for (const [key, child] of Object.entries(out)) if (SCHEMA_KEYWORDS$1.has(key)) out[key] = Array.isArray(child) ? (checkBudget(depth + 1, budget), child.map((item) => rewrite(item, depth + 2, budget))) : rewrite(child, depth + 1, budget);
+	else if (SCHEMA_ARRAY_KEYWORDS$1.has(key) && Array.isArray(child)) {
 		checkBudget(depth + 1, budget);
 		out[key] = child.map((item) => rewrite(item, depth + 2, budget));
-	} else if (SCHEMA_MAP_KEYWORDS.has(key) && child && typeof child === "object" && !Array.isArray(child)) {
+	} else if (SCHEMA_MAP_KEYWORDS$1.has(key) && child && typeof child === "object" && !Array.isArray(child)) {
 		checkBudget(depth + 1, budget);
 		out[key] = Object.fromEntries(Object.entries(child).map(([name, sub]) => [name, rewrite(sub, depth + 2, budget)]));
 	}
@@ -22902,6 +22902,326 @@ function getMCPDiscoveryErrorDetails(error) {
 	};
 }
 //#endregion
+//#region src/client/input-schema-meta-schema.ts
+/**
+* Structural JSON Schema meta-schema, used to check that a server-supplied tool input schema is
+* shaped like a JSON Schema before it is handed to a model provider.
+*
+* Based on https://json-schema.org/draft-07/schema (`$schema`/`$id` dropped so the validator does
+* not try to resolve them). Draft-07 is used because its meta-schema is a single self-contained
+* document; the 2020-12 meta-schema is split across vocabulary documents. Changes from upstream:
+* - `format`, `uniqueItems` and the non-empty `enum` rule are removed, so only wrong value types
+*   and non-schemas in schema positions drop a tool, not regex dialects, non-URI ids or duplicates;
+* - the block at the end of `properties` adds the 2019-09/2020-12 subschema keywords.
+* Unknown keywords stay allowed, as in every dialect.
+*/
+const INPUT_SCHEMA_META_SCHEMA = {
+	title: "Core schema meta-schema",
+	definitions: {
+		schemaArray: {
+			type: "array",
+			minItems: 1,
+			items: { $ref: "#" }
+		},
+		nonNegativeInteger: {
+			type: "integer",
+			minimum: 0
+		},
+		nonNegativeIntegerDefault0: { allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }] },
+		simpleTypes: { enum: [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		] },
+		stringArray: {
+			type: "array",
+			items: { type: "string" },
+			default: []
+		}
+	},
+	type: ["object", "boolean"],
+	properties: {
+		$id: { type: "string" },
+		$schema: { type: "string" },
+		$ref: { type: "string" },
+		$comment: { type: "string" },
+		title: { type: "string" },
+		description: { type: "string" },
+		default: true,
+		readOnly: {
+			type: "boolean",
+			default: false
+		},
+		writeOnly: {
+			type: "boolean",
+			default: false
+		},
+		examples: {
+			type: "array",
+			items: true
+		},
+		multipleOf: {
+			type: "number",
+			exclusiveMinimum: 0
+		},
+		maximum: { type: "number" },
+		exclusiveMaximum: { type: "number" },
+		minimum: { type: "number" },
+		exclusiveMinimum: { type: "number" },
+		maxLength: { $ref: "#/definitions/nonNegativeInteger" },
+		minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+		pattern: { type: "string" },
+		additionalItems: { $ref: "#" },
+		items: {
+			anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
+			default: true
+		},
+		maxItems: { $ref: "#/definitions/nonNegativeInteger" },
+		minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+		uniqueItems: {
+			type: "boolean",
+			default: false
+		},
+		contains: { $ref: "#" },
+		maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
+		minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+		required: { $ref: "#/definitions/stringArray" },
+		additionalProperties: { $ref: "#" },
+		definitions: {
+			type: "object",
+			additionalProperties: { $ref: "#" },
+			default: {}
+		},
+		properties: {
+			type: "object",
+			additionalProperties: { $ref: "#" },
+			default: {}
+		},
+		patternProperties: {
+			type: "object",
+			additionalProperties: { $ref: "#" },
+			default: {}
+		},
+		dependencies: {
+			type: "object",
+			additionalProperties: { anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }] }
+		},
+		propertyNames: { $ref: "#" },
+		const: true,
+		enum: {
+			type: "array",
+			items: true
+		},
+		type: { anyOf: [{ $ref: "#/definitions/simpleTypes" }, {
+			type: "array",
+			items: { $ref: "#/definitions/simpleTypes" },
+			minItems: 1
+		}] },
+		format: { type: "string" },
+		contentMediaType: { type: "string" },
+		contentEncoding: { type: "string" },
+		if: { $ref: "#" },
+		then: { $ref: "#" },
+		else: { $ref: "#" },
+		allOf: { $ref: "#/definitions/schemaArray" },
+		anyOf: { $ref: "#/definitions/schemaArray" },
+		oneOf: { $ref: "#/definitions/schemaArray" },
+		not: { $ref: "#" },
+		$defs: {
+			type: "object",
+			additionalProperties: { $ref: "#" },
+			default: {}
+		},
+		prefixItems: { $ref: "#/definitions/schemaArray" },
+		dependentSchemas: {
+			type: "object",
+			additionalProperties: { $ref: "#" }
+		},
+		dependentRequired: {
+			type: "object",
+			additionalProperties: { $ref: "#/definitions/stringArray" }
+		},
+		unevaluatedItems: { $ref: "#" },
+		unevaluatedProperties: { $ref: "#" },
+		contentSchema: { $ref: "#" }
+	},
+	default: true
+};
+let inputSchemaMetaValidator;
+let inputSchemaMetaValidatorLoad;
+const SCHEMA_TYPES = /* @__PURE__ */ new Set([
+	"array",
+	"boolean",
+	"integer",
+	"null",
+	"number",
+	"object",
+	"string"
+]);
+const SCHEMA_MAP_KEYWORDS = [
+	"$defs",
+	"definitions",
+	"properties",
+	"patternProperties",
+	"dependentSchemas",
+	"dependencies"
+];
+const SCHEMA_ARRAY_KEYWORDS = [
+	"prefixItems",
+	"allOf",
+	"anyOf",
+	"oneOf"
+];
+const SCHEMA_KEYWORDS = [
+	"additionalProperties",
+	"unevaluatedProperties",
+	"additionalItems",
+	"unevaluatedItems",
+	"contains",
+	"propertyNames",
+	"not",
+	"if",
+	"then",
+	"else",
+	"contentSchema"
+];
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const isNumber = (value) => typeof value === "number";
+const isCount = (value) => Number.isInteger(value) && value >= 0;
+const isString = (value) => typeof value === "string";
+const isBoolean = (value) => typeof value === "boolean";
+/** Value types the meta-schema requires for the keywords that do not hold subschemas. */
+const KEYWORD_VALUE_CHECKS = {
+	multipleOf: [(value) => isNumber(value) && value > 0, "a positive number"],
+	...Object.fromEntries([
+		"maximum",
+		"exclusiveMaximum",
+		"minimum",
+		"exclusiveMinimum"
+	].map((k) => [k, [isNumber, "a number"]])),
+	...Object.fromEntries([
+		"maxLength",
+		"minLength",
+		"maxItems",
+		"minItems",
+		"maxProperties",
+		"minProperties"
+	].map((k) => [k, [isCount, "a non-negative integer"]])),
+	...Object.fromEntries([
+		"$id",
+		"$schema",
+		"$ref",
+		"$comment",
+		"title",
+		"description",
+		"pattern",
+		"format",
+		"contentMediaType",
+		"contentEncoding"
+	].map((k) => [k, [isString, "a string"]])),
+	...Object.fromEntries([
+		"readOnly",
+		"writeOnly",
+		"uniqueItems"
+	].map((k) => [k, [isBoolean, "a boolean"]])),
+	examples: [Array.isArray, "an array"],
+	enum: [Array.isArray, "an array"],
+	required: [isStringArray, "an array of strings"]
+};
+/**
+* Fallback for runtimes where the cf-worker validator cannot be imported. Applies the same rules as
+* {@link INPUT_SCHEMA_META_SCHEMA}: every subschema is an object or boolean, and every known
+* keyword has a value of the right type.
+*/
+function getStructuralInputSchemaError(schema) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [{
+		value: schema,
+		path: "#"
+	}];
+	while (stack.length > 0) {
+		const { value, path } = stack.pop();
+		if (typeof value === "boolean") continue;
+		if (!value || typeof value !== "object" || Array.isArray(value)) return `${path}: must be a JSON Schema object or boolean`;
+		if (seen.has(value)) continue;
+		seen.add(value);
+		const record = value;
+		const { type, dependentRequired } = record;
+		const types = Array.isArray(type) ? type : [type];
+		if (type !== void 0 && (types.length === 0 || !types.every((t) => SCHEMA_TYPES.has(t)))) return `${path}/type: must be a JSON Schema type name or a non-empty array of them`;
+		for (const [keyword, [isValid, expected]] of Object.entries(KEYWORD_VALUE_CHECKS)) if (record[keyword] !== void 0 && !isValid(record[keyword])) return `${path}/${keyword}: must be ${expected}`;
+		if (dependentRequired !== void 0 && (!dependentRequired || typeof dependentRequired !== "object" || Array.isArray(dependentRequired) || !Object.values(dependentRequired).every(isStringArray))) return `${path}/dependentRequired: must be an object of string arrays`;
+		for (const keyword of SCHEMA_MAP_KEYWORDS) {
+			const schemas = record[keyword];
+			if (schemas === void 0) continue;
+			if (!schemas || typeof schemas !== "object" || Array.isArray(schemas)) return `${path}/${keyword}: must be an object`;
+			for (const [key, child] of Object.entries(schemas)) {
+				if (keyword === "dependencies" && isStringArray(child)) continue;
+				stack.push({
+					value: child,
+					path: `${path}/${keyword}/${key}`
+				});
+			}
+		}
+		for (const keyword of SCHEMA_ARRAY_KEYWORDS) {
+			const schemas = record[keyword];
+			if (schemas === void 0) continue;
+			if (!Array.isArray(schemas) || schemas.length === 0) return `${path}/${keyword}: must be a non-empty array`;
+			schemas.forEach((child, index) => stack.push({
+				value: child,
+				path: `${path}/${keyword}/${index}`
+			}));
+		}
+		if (Array.isArray(record.items)) {
+			if (record.items.length === 0) return `${path}/items: must be a schema or a non-empty array`;
+			record.items.forEach((child, index) => stack.push({
+				value: child,
+				path: `${path}/items/${index}`
+			}));
+		} else if (record.items !== void 0) stack.push({
+			value: record.items,
+			path: `${path}/items`
+		});
+		for (const keyword of SCHEMA_KEYWORDS) if (record[keyword] !== void 0) stack.push({
+			value: record[keyword],
+			path: `${path}/${keyword}`
+		});
+	}
+}
+/**
+* Loads the SDK's cf-worker validator, which interprets schemas instead of compiling them with
+* `new Function`, so it also runs on Cloudflare Workers. It is imported lazily because
+* `@cfworker/json-schema` builds a URL from `self.location` at import time, which throws in some
+* browser worker locations; importing `@mastra/mcp` must not fail there. Until it has loaded, or
+* if it cannot load, the structural fallback check is used instead.
+*/
+function loadInputSchemaMetaValidator() {
+	inputSchemaMetaValidatorLoad ??= import("@modelcontextprotocol/client/validators/cf-worker").then(({ CfWorkerJsonSchemaValidator }) => {
+		inputSchemaMetaValidator = new CfWorkerJsonSchemaValidator({ draft: "7" }).getValidator(INPUT_SCHEMA_META_SCHEMA);
+	}, () => {});
+	return inputSchemaMetaValidatorLoad;
+}
+/**
+* Checks a server-supplied input schema against {@link INPUT_SCHEMA_META_SCHEMA}, falling back to
+* a structural check while the validator is not loaded. Callers must rule out oversized schemas
+* with getJsonSchemaComplexityError first.
+*/
+function getInputSchemaError(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return "#: input schema must be a JSON object";
+	if (!inputSchemaMetaValidator) return getStructuralInputSchemaError(schema);
+	let result;
+	try {
+		result = inputSchemaMetaValidator(schema);
+	} catch {
+		return;
+	}
+	return result.valid ? void 0 : result.errorMessage.split("; ").at(-1);
+}
+//#endregion
 //#region src/client/url-policy.ts
 /**
 * Redirect status codes the manual redirect loop follows. Other 3xx statuses
@@ -23359,6 +23679,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 	*/
 	constructor({ name, version = "1.0.0", clientInfo, server, timeout = DEFAULT_REQUEST_TIMEOUT_MSEC }) {
 		super({ name: "MastraMCPClient" });
+		loadInputSchemaMetaValidator();
 		this.name = name;
 		this.timeout = timeout;
 		this.logHandler = server.logger;
@@ -23991,14 +24312,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 		return this.jsonSchemaValidator;
 	}
 	convertInputSchema(inputSchema) {
-		const schema = withDefaultDialect("jsonSchema" in inputSchema ? inputSchema.jsonSchema : inputSchema);
-		const standardSchema = toStandardSchema$2(schema);
-		const complexityError = getJsonSchemaComplexityError(schema);
-		if (!complexityError) return standardSchema;
-		return { "~standard": {
-			...standardSchema["~standard"],
-			validate: () => ({ issues: [{ message: complexityError }] })
-		} };
+		return toStandardSchema$2(withDefaultDialect("jsonSchema" in inputSchema ? inputSchema.jsonSchema : inputSchema));
 	}
 	/**
 	* Wraps the output schema with a validator that always succeeds. The tool's execute wrapper
@@ -24080,6 +24394,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 	async tools() {
 		this.log("debug", `Requesting tools from MCP server`);
 		const { tools } = await this.client.listTools({ _meta: this.requestMeta() }, { timeout: this.timeout });
+		await loadInputSchemaMetaValidator();
 		const toolsRes = {};
 		for (const tool of tools) {
 			const mastraTool = this.buildToolFromListEntry(tool, {
@@ -24095,6 +24410,25 @@ var InternalMastraMCPClient = class extends MastraBase {
 	* tools behave identically to discovered ones.
 	*/
 	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);
+		if (inputSchemaError) {
+			const details = {
+				serverName: this.name,
+				toolName: tool.name,
+				reason: inputSchemaError
+			};
+			this.log("warning", `Skipping MCP tool "${tool.name}" with an invalid input schema: ${inputSchemaError}`, details);
+			if (serverMeta.connectFirst) throw new MastraError({
+				id: "MCP_CLIENT_INVALID_TOOL_INPUT_SCHEMA",
+				domain: ErrorDomain.MCP,
+				category: ErrorCategory.THIRD_PARTY,
+				text: `Invalid input schema for MCP tool "${tool.name}": ${inputSchemaError}`,
+				details
+			});
+			return;
+		}
 		try {
 			let requireApproval;
 			let needsApprovalFn;
@@ -25908,7 +26242,9 @@ onListChanged: async (serverName, handler) => {
 	*/
 	async toolFromDefinition({ serverName, definition }) {
 		this.addToInstanceCache();
-		return (await this.getOrCreateClient(serverName, this.getServerConfig(serverName))).toolFromDefinition({ definition });
+		const client = await this.getOrCreateClient(serverName, this.getServerConfig(serverName));
+		await loadInputSchemaMetaValidator();
+		return client.toolFromDefinition({ definition });
 	}
 	/**
 	* Rebuilds an entire cached catalog into a namespaced tool map, without connecting.
@@ -25934,10 +26270,14 @@ onListChanged: async (serverName, handler) => {
 				this.logger.warn("Skipping cached MCP tool definitions for a server that is no longer configured", { serverName });
 				continue;
 			}
-			for (const [toolName, definition] of Object.entries(definitions)) tools[`${serverName}_${toolName}`] = await this.toolFromDefinition({
-				serverName,
-				definition
-			});
+			for (const [toolName, definition] of Object.entries(definitions)) try {
+				tools[`${serverName}_${toolName}`] = await this.toolFromDefinition({
+					serverName,
+					definition
+				});
+			} catch (error) {
+				if (!(error instanceof MastraError && error.id === "MCP_CLIENT_INVALID_TOOL_INPUT_SCHEMA")) throw error;
+			}
 		}
 		return tools;
 	}