@ai-sdk/mcp 2.0.12 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/mcp",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -33,7 +33,7 @@
   "dependencies": {
     "pkce-challenge": "^5.0.1",
     "@ai-sdk/provider": "4.0.3",
-    "@ai-sdk/provider-utils": "5.0.9"
+    "@ai-sdk/provider-utils": "5.0.10"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/index.ts

@@ -22,6 +22,10 @@ export {
   type MCPAppResourceCSP,
   type MCPAppResourceMeta,
 } from './tool/mcp-apps';
+export {
+  fingerprintMCPAppResource,
+  detectMCPAppResourceDrift,
+} from './tool/mcp-app-fingerprint';
 export { ElicitationRequestSchema, ElicitResultSchema } from './tool/types';
 export type {
   CallToolResult,

package/src/tool/mcp-app-fingerprint.ts

@@ -0,0 +1,70 @@
+import { convertUint8ArrayToBase64 } from '@ai-sdk/provider-utils';
+import type { MCPAppResource } from './mcp-apps';
+
+const encoder = new TextEncoder();
+
+// canonicalJSON/toBase64url/the digest below mirror
+// packages/ai/src/util/canonical-hash.ts, which `@ai-sdk/mcp` can't import
+// (wrong dependency direction, not exported). Keep them identical; if a third
+// consumer appears, hoist into @ai-sdk/provider-utils instead.
+
+/**
+ * Deterministic JSON serialization: object keys are sorted so two
+ * structurally-equal values always produce the same string regardless of key
+ * insertion order. Used as the stable input to content hashing.
+ */
+function canonicalJSON(value: unknown): string {
+  if (value == null || typeof value !== 'object') {
+    return JSON.stringify(value ?? null);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJSON).join(',')}]`;
+  }
+  const record = value as Record<string, unknown>;
+  const entries = Object.keys(record)
+    .sort()
+    .map(k => `${JSON.stringify(k)}:${canonicalJSON(record[k])}`);
+  return `{${entries.join(',')}}`;
+}
+
+function toBase64url(bytes: Uint8Array): string {
+  return convertUint8ArrayToBase64(bytes)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+/**
+ * Stable SHA-256 digest (base64url) over an MCP App resource's `html`, `csp`,
+ * and `permissions`.
+ *
+ * Capture a baseline on first load and compare later reads with
+ * {@link detectMCPAppResourceDrift} to detect a changed resource. Baseline
+ * storage and the response are the host's concern, mirroring `fingerprintTools`.
+ */
+export async function fingerprintMCPAppResource(
+  resource: MCPAppResource,
+): Promise<string> {
+  const digest = await crypto.subtle.digest(
+    'SHA-256',
+    encoder.encode(
+      canonicalJSON({
+        html: resource.html,
+        csp: resource.meta?.csp ?? null,
+        permissions: resource.meta?.permissions ?? null,
+      }),
+    ),
+  );
+  return toBase64url(new Uint8Array(digest));
+}
+
+/**
+ * Compares two fingerprints from {@link fingerprintMCPAppResource}. Returns
+ * `true` when the current resource differs from its baseline.
+ */
+export function detectMCPAppResourceDrift(
+  current: string,
+  baseline: string,
+): boolean {
+  return current !== baseline;
+}

package/src/tool/mcp-apps.ts

@@ -1,5 +1,6 @@
 import { isJSONObject, type JSONObject } from '@ai-sdk/provider';
 import { convertBase64ToUint8Array } from '@ai-sdk/provider-utils';
+import * as z4 from 'zod/v4';
 import type { MCPClient } from './mcp-client';
 import type {
   ClientCapabilities,
@@ -87,12 +88,42 @@ function getToolUiMeta(meta?: ToolMeta): JSONObject | undefined {
   return isJSONObject(uiMeta) ? uiMeta : undefined;
 }
 
+/**
+ * Filters a string array to its string elements, dropping the field entirely
+ * (rather than failing the parse) if the value is not an array.
+ */
+const optionalStringArray = z4
+  .array(z4.unknown())
+  .transform(items => items.filter((v): v is string => typeof v === 'string'))
+  .optional()
+  .catch(undefined);
+
+const MCPAppResourceCSPSchema = z4.looseObject({
+  connectDomains: optionalStringArray,
+  resourceDomains: optionalStringArray,
+  frameDomains: optionalStringArray,
+});
+
+/**
+ * Runtime schema for `_meta.ui` on an MCP App resource. Each known field is
+ * validated; a malformed field is dropped (`.catch(undefined)`) rather than
+ * failing the whole parse, and unknown keys pass through for forward-compat.
+ */
+const MCPAppResourceMetaSchema = z4.looseObject({
+  prefersBorder: z4.boolean().optional().catch(undefined),
+  csp: MCPAppResourceCSPSchema.optional().catch(undefined),
+  permissions: z4.record(z4.string(), z4.unknown()).optional().catch(undefined),
+});
+
 function getResourceUiMeta(meta: unknown): MCPAppResourceMeta | undefined {
   const resourceMeta = isJSONObject(meta) ? meta : undefined;
   const rawUiMeta = resourceMeta?.ui;
-  const uiMeta = isJSONObject(rawUiMeta) ? rawUiMeta : undefined;
+  if (!isJSONObject(rawUiMeta)) {
+    return undefined;
+  }
 
-  return uiMeta as MCPAppResourceMeta | undefined;
+  const parsed = MCPAppResourceMetaSchema.safeParse(rawUiMeta);
+  return parsed.success ? (parsed.data as MCPAppResourceMeta) : undefined;
 }
 
 function parseVisibility(value: unknown): MCPAppToolVisibility[] | undefined {