@evantahler/mcpx 0.21.3 → 0.21.5

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@evantahler/mcpx",
-	"version": "0.21.3",
+	"version": "0.21.5",
 	"description": "A command-line interface for MCP servers. curl for MCP.",
 	"type": "module",
 	"exports": {

package/src/search/onnx-wasm-paths.ts

@@ -10,9 +10,20 @@
 // that environment node_modules exists and onnxruntime-web is reachable
 // through normal module resolution.
 
+// The relative `../../node_modules/...` paths only resolve from the local repo
+// layout (and inside `bun build --compile`). When this file is shipped via npm,
+// deps are hoisted, so consumer `tsc` runs hit TS2307. The `ts-ignore` directive
+// below silences that for consumers; we avoid the stricter `expect-error` form
+// because in the local repo the path resolves fine and there would be no error
+// to expect. At runtime the dynamic import in semantic.ts is wrapped in
+// try/catch and falls back to transformers.js's default WASM loader (issue #85).
+// biome-ignore lint/suspicious/noTsIgnore: must stay as ts-ignore per comment above
+// @ts-ignore - dynamic-only import
 import wasmMjsPath from "../../node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.asyncify.mjs" with {
 	type: "file",
 };
+// biome-ignore lint/suspicious/noTsIgnore: must stay as ts-ignore per comment above
+// @ts-ignore - dynamic-only import
 import wasmBinPath from "../../node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.asyncify.wasm" with {
 	type: "file",
 };

package/src/validation/schema.ts

@@ -26,7 +26,7 @@ function validateWithSchema(
 
 	if (!validate) {
 		try {
-			validate = ajv.compile(schema);
+			validate = ajv.compile(normalizeSchema(schema));
 			validatorCache.set(cacheKey, validate);
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : "unknown error";
@@ -60,6 +60,64 @@ export function validateElicitationResponse(
 	return validateWithSchema(`__elicitation__${JSON.stringify(schema)}`, schema, input);
 }
 
+type JsonPrimitive = string | number | boolean | null;
+
+function isPrimitive(v: unknown): v is JsonPrimitive {
+	return v === null || ["string", "number", "boolean"].includes(typeof v);
+}
+
+function primitiveJsonType(v: JsonPrimitive): "string" | "number" | "boolean" | "null" {
+	if (v === null) return "null";
+	if (typeof v === "boolean") return "boolean";
+	if (typeof v === "number") return "number";
+	return "string";
+}
+
+/**
+ * Normalize a JSON Schema before handing it to Ajv. Rewrites the malformed
+ * shape `{ type: "array", enum: [<primitives>], items: { type: <matching> } }`
+ * — published by some real MCP servers — into `{ type: "array", items: { ..., enum: [...] } }`.
+ * Without this fix Ajv compares the whole array value against the primitive enum
+ * and rejects every input. Returns a deep clone; the input schema is untouched.
+ */
+function normalizeSchema(schema: Record<string, unknown>): Record<string, unknown> {
+	return walk(schema) as Record<string, unknown>;
+}
+
+function walk(node: unknown): unknown {
+	if (Array.isArray(node)) {
+		return node.map(walk);
+	}
+	if (!node || typeof node !== "object") {
+		return node;
+	}
+
+	const out: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
+		out[key] = walk(value);
+	}
+
+	if (out.type === "array" && Array.isArray(out.enum) && out.enum.every(isPrimitive)) {
+		const items = out.items;
+		const enumValues = out.enum as JsonPrimitive[];
+		if (items && typeof items === "object" && !Array.isArray(items)) {
+			const itemsObj = items as Record<string, unknown>;
+			const enumType = primitiveJsonType(enumValues[0]!);
+			const allSameType = enumValues.every((v) => primitiveJsonType(v) === enumType);
+			const itemsTypeMatches =
+				itemsObj.type === undefined ||
+				itemsObj.type === enumType ||
+				(Array.isArray(itemsObj.type) && itemsObj.type.includes(enumType));
+			if (allSameType && itemsTypeMatches && itemsObj.enum === undefined) {
+				out.items = { ...itemsObj, enum: enumValues };
+				delete out.enum;
+			}
+		}
+	}
+
+	return out;
+}
+
 function formatAjvError(err: ErrorObject): ValidationError {
 	const path = err.instancePath ? err.instancePath.replace(/^\//, "").replace(/\//g, ".") : "(root)";