@ai-sdk/mcp 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/index.js

@@ -1,54 +1,20 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name3 in all)
-    __defProp(target, name3, { get: all[name3], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ElicitResultSchema: () => ElicitResultSchema,
-  ElicitationRequestSchema: () => ElicitationRequestSchema,
-  UnauthorizedError: () => UnauthorizedError,
-  auth: () => auth,
-  createMCPClient: () => createMCPClient,
-  experimental_createMCPClient: () => createMCPClient
-});
-module.exports = __toCommonJS(src_exports);
-
 // src/tool/mcp-client.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+import {
+  asSchema,
+  dynamicTool,
+  jsonSchema,
+  safeParseJSON,
+  safeValidateTypes,
+  tool
+} from "@ai-sdk/provider-utils";
 
 // src/error/mcp-client-error.ts
-var import_provider = require("@ai-sdk/provider");
+import { AISDKError } from "@ai-sdk/provider";
 var name = "AI_MCPClientError";
 var marker = `vercel.ai.error.${name}`;
 var symbol = Symbol.for(marker);
 var _a, _b;
-var MCPClientError = class extends (_b = import_provider.AISDKError, _a = symbol, _b) {
+var MCPClientError = class extends (_b = AISDKError, _a = symbol, _b) {
   constructor({
     name: name3 = "MCPClientError",
     message,
@@ -62,18 +28,22 @@ var MCPClientError = class extends (_b = import_provider.AISDKError, _a = symbol
     this.code = code;
   }
   static isInstance(error) {
-    return import_provider.AISDKError.hasMarker(error, marker);
+    return AISDKError.hasMarker(error, marker);
   }
 };
 
 // src/tool/mcp-sse-transport.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
+import {
+  EventSourceParserStream,
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent
+} from "@ai-sdk/provider-utils";
 
 // src/tool/json-rpc-message.ts
-var import_v42 = require("zod/v4");
+import { z as z2 } from "zod/v4";
 
 // src/tool/types.ts
-var import_v4 = require("zod/v4");
+import { z } from "zod/v4";
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
 var SUPPORTED_PROTOCOL_VERSIONS = [
   LATEST_PROTOCOL_VERSION,
@@ -81,229 +51,230 @@ var SUPPORTED_PROTOCOL_VERSIONS = [
   "2025-03-26",
   "2024-11-05"
 ];
-var ToolMetaSchema = import_v4.z.optional(import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()));
-var ClientOrServerImplementationSchema = import_v4.z.looseObject({
-  name: import_v4.z.string(),
-  version: import_v4.z.string()
+var ToolMetaSchema = z.optional(z.record(z.string(), z.unknown()));
+var ClientOrServerImplementationSchema = z.looseObject({
+  name: z.string(),
+  version: z.string(),
+  title: z.optional(z.string())
 });
-var BaseParamsSchema = import_v4.z.looseObject({
-  _meta: import_v4.z.optional(import_v4.z.object({}).loose())
+var BaseParamsSchema = z.looseObject({
+  _meta: z.optional(z.object({}).loose())
 });
 var ResultSchema = BaseParamsSchema;
-var RequestSchema = import_v4.z.object({
-  method: import_v4.z.string(),
-  params: import_v4.z.optional(BaseParamsSchema)
+var RequestSchema = z.object({
+  method: z.string(),
+  params: z.optional(BaseParamsSchema)
 });
-var ElicitationCapabilitySchema = import_v4.z.object({
-  applyDefaults: import_v4.z.optional(import_v4.z.boolean())
+var ElicitationCapabilitySchema = z.object({
+  applyDefaults: z.optional(z.boolean())
 }).loose();
-var ServerCapabilitiesSchema = import_v4.z.looseObject({
-  experimental: import_v4.z.optional(import_v4.z.object({}).loose()),
-  logging: import_v4.z.optional(import_v4.z.object({}).loose()),
-  prompts: import_v4.z.optional(
-    import_v4.z.looseObject({
-      listChanged: import_v4.z.optional(import_v4.z.boolean())
+var ServerCapabilitiesSchema = z.looseObject({
+  experimental: z.optional(z.object({}).loose()),
+  logging: z.optional(z.object({}).loose()),
+  prompts: z.optional(
+    z.looseObject({
+      listChanged: z.optional(z.boolean())
     })
   ),
-  resources: import_v4.z.optional(
-    import_v4.z.looseObject({
-      subscribe: import_v4.z.optional(import_v4.z.boolean()),
-      listChanged: import_v4.z.optional(import_v4.z.boolean())
+  resources: z.optional(
+    z.looseObject({
+      subscribe: z.optional(z.boolean()),
+      listChanged: z.optional(z.boolean())
     })
   ),
-  tools: import_v4.z.optional(
-    import_v4.z.looseObject({
-      listChanged: import_v4.z.optional(import_v4.z.boolean())
+  tools: z.optional(
+    z.looseObject({
+      listChanged: z.optional(z.boolean())
     })
   ),
-  elicitation: import_v4.z.optional(ElicitationCapabilitySchema)
+  elicitation: z.optional(ElicitationCapabilitySchema)
 });
-var ClientCapabilitiesSchema = import_v4.z.object({
-  elicitation: import_v4.z.optional(ElicitationCapabilitySchema)
+var ClientCapabilitiesSchema = z.object({
+  elicitation: z.optional(ElicitationCapabilitySchema)
 }).loose();
 var InitializeResultSchema = ResultSchema.extend({
-  protocolVersion: import_v4.z.string(),
+  protocolVersion: z.string(),
   capabilities: ServerCapabilitiesSchema,
   serverInfo: ClientOrServerImplementationSchema,
-  instructions: import_v4.z.optional(import_v4.z.string())
+  instructions: z.optional(z.string())
 });
 var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: import_v4.z.optional(import_v4.z.string())
+  nextCursor: z.optional(z.string())
 });
-var ToolSchema = import_v4.z.object({
-  name: import_v4.z.string(),
+var ToolSchema = z.object({
+  name: z.string(),
   /**
    * @see https://modelcontextprotocol.io/specification/2025-11-25/server/tools#tool
    */
-  title: import_v4.z.optional(import_v4.z.string()),
-  description: import_v4.z.optional(import_v4.z.string()),
-  inputSchema: import_v4.z.object({
-    type: import_v4.z.literal("object"),
-    properties: import_v4.z.optional(import_v4.z.object({}).loose())
+  title: z.optional(z.string()),
+  description: z.optional(z.string()),
+  inputSchema: z.object({
+    type: z.literal("object"),
+    properties: z.optional(z.object({}).loose())
   }).loose(),
   /**
    * @see https://modelcontextprotocol.io/specification/2025-06-18/server/tools#output-schema
    */
-  outputSchema: import_v4.z.optional(import_v4.z.object({}).loose()),
-  annotations: import_v4.z.optional(
-    import_v4.z.object({
-      title: import_v4.z.optional(import_v4.z.string())
+  outputSchema: z.optional(z.object({}).loose()),
+  annotations: z.optional(
+    z.object({
+      title: z.optional(z.string())
     }).loose()
   ),
   _meta: ToolMetaSchema
 }).loose();
 var ListToolsResultSchema = PaginatedResultSchema.extend({
-  tools: import_v4.z.array(ToolSchema)
+  tools: z.array(ToolSchema)
 });
-var TextContentSchema = import_v4.z.object({
-  type: import_v4.z.literal("text"),
-  text: import_v4.z.string()
+var TextContentSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
 }).loose();
-var ImageContentSchema = import_v4.z.object({
-  type: import_v4.z.literal("image"),
-  data: import_v4.z.base64(),
-  mimeType: import_v4.z.string()
+var ImageContentSchema = z.object({
+  type: z.literal("image"),
+  data: z.base64(),
+  mimeType: z.string()
 }).loose();
-var ResourceSchema = import_v4.z.object({
-  uri: import_v4.z.string(),
-  name: import_v4.z.string(),
-  title: import_v4.z.optional(import_v4.z.string()),
-  description: import_v4.z.optional(import_v4.z.string()),
-  mimeType: import_v4.z.optional(import_v4.z.string()),
-  size: import_v4.z.optional(import_v4.z.number())
+var ResourceSchema = z.object({
+  uri: z.string(),
+  name: z.string(),
+  title: z.optional(z.string()),
+  description: z.optional(z.string()),
+  mimeType: z.optional(z.string()),
+  size: z.optional(z.number())
 }).loose();
 var ListResourcesResultSchema = PaginatedResultSchema.extend({
-  resources: import_v4.z.array(ResourceSchema)
+  resources: z.array(ResourceSchema)
 });
-var ResourceContentsSchema = import_v4.z.object({
+var ResourceContentsSchema = z.object({
   /**
    * The URI of this resource.
    */
-  uri: import_v4.z.string(),
+  uri: z.string(),
   /**
    * Optional display name of the resource content.
    */
-  name: import_v4.z.optional(import_v4.z.string()),
+  name: z.optional(z.string()),
   /**
    * Optional human readable title.
    */
-  title: import_v4.z.optional(import_v4.z.string()),
+  title: z.optional(z.string()),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: import_v4.z.optional(import_v4.z.string())
+  mimeType: z.optional(z.string())
 }).loose();
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: import_v4.z.string()
+  text: z.string()
 });
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: import_v4.z.base64()
+  blob: z.base64()
 });
-var EmbeddedResourceSchema = import_v4.z.object({
-  type: import_v4.z.literal("resource"),
-  resource: import_v4.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
+var EmbeddedResourceSchema = z.object({
+  type: z.literal("resource"),
+  resource: z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
 }).loose();
 var CallToolResultSchema = ResultSchema.extend({
-  content: import_v4.z.array(
-    import_v4.z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
+  content: z.array(
+    z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
   ),
   /**
    * @see https://modelcontextprotocol.io/specification/2025-06-18/server/tools#structured-content
    */
-  structuredContent: import_v4.z.optional(import_v4.z.unknown()),
-  isError: import_v4.z.boolean().default(false).optional()
+  structuredContent: z.optional(z.unknown()),
+  isError: z.boolean().default(false).optional()
 }).or(
   ResultSchema.extend({
-    toolResult: import_v4.z.unknown()
+    toolResult: z.unknown()
   })
 );
-var ResourceTemplateSchema = import_v4.z.object({
-  uriTemplate: import_v4.z.string(),
-  name: import_v4.z.string(),
-  title: import_v4.z.optional(import_v4.z.string()),
-  description: import_v4.z.optional(import_v4.z.string()),
-  mimeType: import_v4.z.optional(import_v4.z.string())
+var ResourceTemplateSchema = z.object({
+  uriTemplate: z.string(),
+  name: z.string(),
+  title: z.optional(z.string()),
+  description: z.optional(z.string()),
+  mimeType: z.optional(z.string())
 }).loose();
 var ListResourceTemplatesResultSchema = ResultSchema.extend({
-  resourceTemplates: import_v4.z.array(ResourceTemplateSchema)
+  resourceTemplates: z.array(ResourceTemplateSchema)
 });
 var ReadResourceResultSchema = ResultSchema.extend({
-  contents: import_v4.z.array(
-    import_v4.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
+  contents: z.array(
+    z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
   )
 });
-var PromptArgumentSchema = import_v4.z.object({
-  name: import_v4.z.string(),
-  description: import_v4.z.optional(import_v4.z.string()),
-  required: import_v4.z.optional(import_v4.z.boolean())
+var PromptArgumentSchema = z.object({
+  name: z.string(),
+  description: z.optional(z.string()),
+  required: z.optional(z.boolean())
 }).loose();
-var PromptSchema = import_v4.z.object({
-  name: import_v4.z.string(),
-  title: import_v4.z.optional(import_v4.z.string()),
-  description: import_v4.z.optional(import_v4.z.string()),
-  arguments: import_v4.z.optional(import_v4.z.array(PromptArgumentSchema))
+var PromptSchema = z.object({
+  name: z.string(),
+  title: z.optional(z.string()),
+  description: z.optional(z.string()),
+  arguments: z.optional(z.array(PromptArgumentSchema))
 }).loose();
 var ListPromptsResultSchema = PaginatedResultSchema.extend({
-  prompts: import_v4.z.array(PromptSchema)
+  prompts: z.array(PromptSchema)
 });
-var PromptMessageSchema = import_v4.z.object({
-  role: import_v4.z.union([import_v4.z.literal("user"), import_v4.z.literal("assistant")]),
-  content: import_v4.z.union([
+var PromptMessageSchema = z.object({
+  role: z.union([z.literal("user"), z.literal("assistant")]),
+  content: z.union([
     TextContentSchema,
     ImageContentSchema,
     EmbeddedResourceSchema
   ])
 }).loose();
 var GetPromptResultSchema = ResultSchema.extend({
-  description: import_v4.z.optional(import_v4.z.string()),
-  messages: import_v4.z.array(PromptMessageSchema)
+  description: z.optional(z.string()),
+  messages: z.array(PromptMessageSchema)
 });
 var ElicitationRequestParamsSchema = BaseParamsSchema.extend({
-  message: import_v4.z.string(),
-  requestedSchema: import_v4.z.unknown()
+  message: z.string(),
+  requestedSchema: z.unknown()
 });
 var ElicitationRequestSchema = RequestSchema.extend({
-  method: import_v4.z.literal("elicitation/create"),
+  method: z.literal("elicitation/create"),
   params: ElicitationRequestParamsSchema
 });
 var ElicitResultSchema = ResultSchema.extend({
-  action: import_v4.z.union([
-    import_v4.z.literal("accept"),
-    import_v4.z.literal("decline"),
-    import_v4.z.literal("cancel")
+  action: z.union([
+    z.literal("accept"),
+    z.literal("decline"),
+    z.literal("cancel")
   ]),
-  content: import_v4.z.optional(import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()))
+  content: z.optional(z.record(z.string(), z.unknown()))
 });
 
 // src/tool/json-rpc-message.ts
 var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = import_v42.z.object({
-  jsonrpc: import_v42.z.literal(JSONRPC_VERSION),
-  id: import_v42.z.union([import_v42.z.string(), import_v42.z.number().int()])
+var JSONRPCRequestSchema = z2.object({
+  jsonrpc: z2.literal(JSONRPC_VERSION),
+  id: z2.union([z2.string(), z2.number().int()])
 }).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = import_v42.z.object({
-  jsonrpc: import_v42.z.literal(JSONRPC_VERSION),
-  id: import_v42.z.union([import_v42.z.string(), import_v42.z.number().int()]),
+var JSONRPCResponseSchema = z2.object({
+  jsonrpc: z2.literal(JSONRPC_VERSION),
+  id: z2.union([z2.string(), z2.number().int()]),
   result: ResultSchema
 }).strict();
-var JSONRPCErrorSchema = import_v42.z.object({
-  jsonrpc: import_v42.z.literal(JSONRPC_VERSION),
-  id: import_v42.z.union([import_v42.z.string(), import_v42.z.number().int()]),
-  error: import_v42.z.object({
-    code: import_v42.z.number().int(),
-    message: import_v42.z.string(),
-    data: import_v42.z.optional(import_v42.z.unknown())
+var JSONRPCErrorSchema = z2.object({
+  jsonrpc: z2.literal(JSONRPC_VERSION),
+  id: z2.union([z2.string(), z2.number().int()]),
+  error: z2.object({
+    code: z2.number().int(),
+    message: z2.string(),
+    data: z2.optional(z2.unknown())
   })
 }).strict();
-var JSONRPCNotificationSchema = import_v42.z.object({
-  jsonrpc: import_v42.z.literal(JSONRPC_VERSION)
+var JSONRPCNotificationSchema = z2.object({
+  jsonrpc: z2.literal(JSONRPC_VERSION)
 }).merge(
-  import_v42.z.object({
-    method: import_v42.z.string(),
-    params: import_v42.z.optional(BaseParamsSchema)
+  z2.object({
+    method: z2.string(),
+    params: z2.optional(BaseParamsSchema)
   })
 ).strict();
-var JSONRPCMessageSchema = import_v42.z.union([
+var JSONRPCMessageSchema = z2.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResponseSchema,
@@ -314,27 +285,27 @@ var JSONRPCMessageSchema = import_v42.z.union([
 var VERSION = typeof __PACKAGE_VERSION__ !== "undefined" ? __PACKAGE_VERSION__ : "0.0.0-test";
 
 // src/tool/oauth.ts
-var import_pkce_challenge = __toESM(require("pkce-challenge"));
+import pkceChallenge from "pkce-challenge";
 
 // src/tool/oauth-types.ts
-var import_v43 = require("zod/v4");
-var OAuthTokensSchema = import_v43.z.object({
-  access_token: import_v43.z.string(),
-  id_token: import_v43.z.string().optional(),
+import { z as z3 } from "zod/v4";
+var OAuthTokensSchema = z3.object({
+  access_token: z3.string(),
+  id_token: z3.string().optional(),
   // Optional for OAuth 2.1, but necessary in OpenID Connect
-  token_type: import_v43.z.string(),
-  expires_in: import_v43.z.number().optional(),
-  scope: import_v43.z.string().optional(),
-  refresh_token: import_v43.z.string().optional()
+  token_type: z3.string(),
+  expires_in: z3.number().optional(),
+  scope: z3.string().optional(),
+  refresh_token: z3.string().optional()
 }).strip();
-var SafeUrlSchema = import_v43.z.string().url().superRefine((val, ctx) => {
+var SafeUrlSchema = z3.string().url().superRefine((val, ctx) => {
   if (!URL.canParse(val)) {
     ctx.addIssue({
-      code: import_v43.z.ZodIssueCode.custom,
+      code: z3.ZodIssueCode.custom,
       message: "URL must be parseable",
       fatal: true
     });
-    return import_v43.z.NEVER;
+    return z3.NEVER;
   }
 }).refine(
   (url) => {
@@ -343,94 +314,94 @@ var SafeUrlSchema = import_v43.z.string().url().superRefine((val, ctx) => {
   },
   { message: "URL cannot use javascript:, data:, or vbscript: scheme" }
 );
-var OAuthProtectedResourceMetadataSchema = import_v43.z.object({
-  resource: import_v43.z.string().url(),
-  authorization_servers: import_v43.z.array(SafeUrlSchema).optional(),
-  jwks_uri: import_v43.z.string().url().optional(),
-  scopes_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  bearer_methods_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  resource_signing_alg_values_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  resource_name: import_v43.z.string().optional(),
-  resource_documentation: import_v43.z.string().optional(),
-  resource_policy_uri: import_v43.z.string().url().optional(),
-  resource_tos_uri: import_v43.z.string().url().optional(),
-  tls_client_certificate_bound_access_tokens: import_v43.z.boolean().optional(),
-  authorization_details_types_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  dpop_signing_alg_values_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  dpop_bound_access_tokens_required: import_v43.z.boolean().optional()
+var OAuthProtectedResourceMetadataSchema = z3.object({
+  resource: z3.string().url(),
+  authorization_servers: z3.array(SafeUrlSchema).optional(),
+  jwks_uri: z3.string().url().optional(),
+  scopes_supported: z3.array(z3.string()).optional(),
+  bearer_methods_supported: z3.array(z3.string()).optional(),
+  resource_signing_alg_values_supported: z3.array(z3.string()).optional(),
+  resource_name: z3.string().optional(),
+  resource_documentation: z3.string().optional(),
+  resource_policy_uri: z3.string().url().optional(),
+  resource_tos_uri: z3.string().url().optional(),
+  tls_client_certificate_bound_access_tokens: z3.boolean().optional(),
+  authorization_details_types_supported: z3.array(z3.string()).optional(),
+  dpop_signing_alg_values_supported: z3.array(z3.string()).optional(),
+  dpop_bound_access_tokens_required: z3.boolean().optional()
 }).passthrough();
-var OAuthMetadataSchema = import_v43.z.object({
-  issuer: import_v43.z.string(),
+var OAuthMetadataSchema = z3.object({
+  issuer: z3.string(),
   authorization_endpoint: SafeUrlSchema,
   token_endpoint: SafeUrlSchema,
   registration_endpoint: SafeUrlSchema.optional(),
-  scopes_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  response_types_supported: import_v43.z.array(import_v43.z.string()),
-  grant_types_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  code_challenge_methods_supported: import_v43.z.array(import_v43.z.string()),
-  token_endpoint_auth_methods_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  token_endpoint_auth_signing_alg_values_supported: import_v43.z.array(import_v43.z.string()).optional()
+  scopes_supported: z3.array(z3.string()).optional(),
+  response_types_supported: z3.array(z3.string()),
+  grant_types_supported: z3.array(z3.string()).optional(),
+  code_challenge_methods_supported: z3.array(z3.string()),
+  token_endpoint_auth_methods_supported: z3.array(z3.string()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: z3.array(z3.string()).optional()
 }).passthrough();
-var OpenIdProviderMetadataSchema = import_v43.z.object({
-  issuer: import_v43.z.string(),
+var OpenIdProviderMetadataSchema = z3.object({
+  issuer: z3.string(),
   authorization_endpoint: SafeUrlSchema,
   token_endpoint: SafeUrlSchema,
   userinfo_endpoint: SafeUrlSchema.optional(),
   jwks_uri: SafeUrlSchema,
   registration_endpoint: SafeUrlSchema.optional(),
-  scopes_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  response_types_supported: import_v43.z.array(import_v43.z.string()),
-  grant_types_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  subject_types_supported: import_v43.z.array(import_v43.z.string()),
-  id_token_signing_alg_values_supported: import_v43.z.array(import_v43.z.string()),
-  claims_supported: import_v43.z.array(import_v43.z.string()).optional(),
-  token_endpoint_auth_methods_supported: import_v43.z.array(import_v43.z.string()).optional()
+  scopes_supported: z3.array(z3.string()).optional(),
+  response_types_supported: z3.array(z3.string()),
+  grant_types_supported: z3.array(z3.string()).optional(),
+  subject_types_supported: z3.array(z3.string()),
+  id_token_signing_alg_values_supported: z3.array(z3.string()),
+  claims_supported: z3.array(z3.string()).optional(),
+  token_endpoint_auth_methods_supported: z3.array(z3.string()).optional()
 }).passthrough();
 var OpenIdProviderDiscoveryMetadataSchema = OpenIdProviderMetadataSchema.merge(
   OAuthMetadataSchema.pick({
     code_challenge_methods_supported: true
   })
 );
-var OAuthClientInformationSchema = import_v43.z.object({
-  client_id: import_v43.z.string(),
-  client_secret: import_v43.z.string().optional(),
-  client_id_issued_at: import_v43.z.number().optional(),
-  client_secret_expires_at: import_v43.z.number().optional()
+var OAuthClientInformationSchema = z3.object({
+  client_id: z3.string(),
+  client_secret: z3.string().optional(),
+  client_id_issued_at: z3.number().optional(),
+  client_secret_expires_at: z3.number().optional()
 }).strip();
-var OAuthClientMetadataSchema = import_v43.z.object({
-  redirect_uris: import_v43.z.array(SafeUrlSchema),
-  token_endpoint_auth_method: import_v43.z.string().optional(),
-  grant_types: import_v43.z.array(import_v43.z.string()).optional(),
-  response_types: import_v43.z.array(import_v43.z.string()).optional(),
-  client_name: import_v43.z.string().optional(),
+var OAuthClientMetadataSchema = z3.object({
+  redirect_uris: z3.array(SafeUrlSchema),
+  token_endpoint_auth_method: z3.string().optional(),
+  grant_types: z3.array(z3.string()).optional(),
+  response_types: z3.array(z3.string()).optional(),
+  client_name: z3.string().optional(),
   client_uri: SafeUrlSchema.optional(),
   logo_uri: SafeUrlSchema.optional(),
-  scope: import_v43.z.string().optional(),
-  contacts: import_v43.z.array(import_v43.z.string()).optional(),
+  scope: z3.string().optional(),
+  contacts: z3.array(z3.string()).optional(),
   tos_uri: SafeUrlSchema.optional(),
-  policy_uri: import_v43.z.string().optional(),
+  policy_uri: z3.string().optional(),
   jwks_uri: SafeUrlSchema.optional(),
-  jwks: import_v43.z.any().optional(),
-  software_id: import_v43.z.string().optional(),
-  software_version: import_v43.z.string().optional(),
-  software_statement: import_v43.z.string().optional()
+  jwks: z3.any().optional(),
+  software_id: z3.string().optional(),
+  software_version: z3.string().optional(),
+  software_statement: z3.string().optional()
 }).strip();
-var OAuthErrorResponseSchema = import_v43.z.object({
-  error: import_v43.z.string(),
-  error_description: import_v43.z.string().optional(),
-  error_uri: import_v43.z.string().optional()
+var OAuthErrorResponseSchema = z3.object({
+  error: z3.string(),
+  error_description: z3.string().optional(),
+  error_uri: z3.string().optional()
 });
 var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(
   OAuthClientInformationSchema
 );
 
 // src/error/oauth-error.ts
-var import_provider2 = require("@ai-sdk/provider");
+import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
 var name2 = "AI_MCPClientOAuthError";
 var marker2 = `vercel.ai.error.${name2}`;
 var symbol2 = Symbol.for(marker2);
 var _a2, _b2;
-var MCPClientOAuthError = class extends (_b2 = import_provider2.AISDKError, _a2 = symbol2, _b2) {
+var MCPClientOAuthError = class extends (_b2 = AISDKError2, _a2 = symbol2, _b2) {
   constructor({
     name: name3 = "MCPClientOAuthError",
     message,
@@ -440,7 +411,7 @@ var MCPClientOAuthError = class extends (_b2 = import_provider2.AISDKError, _a2
     this[_a2] = true;
   }
   static isInstance(error) {
-    return import_provider2.AISDKError.hasMarker(error, marker2);
+    return AISDKError2.hasMarker(error, marker2);
   }
 };
 var ServerError = class extends MCPClientOAuthError {
@@ -468,6 +439,13 @@ function resourceUrlFromServerUrl(url) {
   resourceURL.hash = "";
   return resourceURL;
 }
+function resourceUrlStripSlash(resource) {
+  const href = resource.href;
+  if (resource.pathname === "/" && href.endsWith("/")) {
+    return href.slice(0, -1);
+  }
+  return href;
+}
 function checkResourceAllowed({
   requestedResource,
   configuredResource
@@ -685,7 +663,7 @@ async function startAuthorization(authorizationServerUrl, {
   } else {
     authorizationUrl = new URL("/authorize", authorizationServerUrl);
   }
-  const challenge = await (0, import_pkce_challenge.default)();
+  const challenge = await pkceChallenge();
   const codeVerifier = challenge.code_verifier;
   const codeChallenge = challenge.code_challenge;
   authorizationUrl.searchParams.set("response_type", responseType);
@@ -706,7 +684,10 @@ async function startAuthorization(authorizationServerUrl, {
     authorizationUrl.searchParams.append("prompt", "consent");
   }
   if (resource) {
-    authorizationUrl.searchParams.set("resource", resource.href);
+    authorizationUrl.searchParams.set(
+      "resource",
+      resourceUrlStripSlash(resource)
+    );
   }
   return { authorizationUrl, codeVerifier };
 }
@@ -815,7 +796,7 @@ async function exchangeAuthorization(authorizationServerUrl, {
     applyClientAuthentication(authMethod, clientInformation, headers, params);
   }
   if (resource) {
-    params.set("resource", resource.href);
+    params.set("resource", resourceUrlStripSlash(resource));
   }
   const response = await (fetchFn != null ? fetchFn : fetch)(tokenUrl, {
     method: "POST",
@@ -867,7 +848,7 @@ async function refreshAuthorization(authorizationServerUrl, {
     applyClientAuthentication(authMethod, clientInformation, headers, params);
   }
   if (resource) {
-    params.set("resource", resource.href);
+    params.set("resource", resourceUrlStripSlash(resource));
   }
   const response = await (fetchFn != null ? fetchFn : fetch)(tokenUrl, {
     method: "POST",
@@ -1072,12 +1053,16 @@ var SseMCPTransport = class {
   constructor({
     url,
     headers,
-    authProvider
+    authProvider,
+    redirect = "error",
+    fetch: fetchFn
   }) {
     this.connected = false;
     this.url = new URL(url);
     this.headers = headers;
     this.authProvider = authProvider;
+    this.redirectMode = redirect;
+    this.fetchFn = fetchFn != null ? fetchFn : globalThis.fetch;
   }
   async commonHeaders(base) {
     const headers = {
@@ -1091,10 +1076,10 @@ var SseMCPTransport = class {
         headers["Authorization"] = `Bearer ${tokens.access_token}`;
       }
     }
-    return (0, import_provider_utils.withUserAgentSuffix)(
+    return withUserAgentSuffix(
       headers,
       `ai-sdk/${VERSION}`,
-      (0, import_provider_utils.getRuntimeEnvironmentUserAgent)()
+      getRuntimeEnvironmentUserAgent()
     );
   }
   async start() {
@@ -1109,16 +1094,18 @@ var SseMCPTransport = class {
           const headers = await this.commonHeaders({
             Accept: "text/event-stream"
           });
-          const response = await fetch(this.url.href, {
+          const response = await this.fetchFn(this.url.href, {
             headers,
-            signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal
+            signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal,
+            redirect: this.redirectMode
           });
           if (response.status === 401 && this.authProvider && !triedAuth) {
             this.resourceMetadataUrl = extractResourceMetadataUrl(response);
             try {
               const result = await auth(this.authProvider, {
                 serverUrl: this.url,
-                resourceMetadataUrl: this.resourceMetadataUrl
+                resourceMetadataUrl: this.resourceMetadataUrl,
+                fetchFn: this.fetchFn
               });
               if (result !== "AUTHORIZED") {
                 const error = new UnauthorizedError();
@@ -1142,7 +1129,7 @@ var SseMCPTransport = class {
             (_d = this.onerror) == null ? void 0 : _d.call(this, error);
             return reject(error);
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new import_provider_utils.EventSourceParserStream());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a4, _b4, _c2;
@@ -1230,15 +1217,17 @@ var SseMCPTransport = class {
           method: "POST",
           headers,
           body: JSON.stringify(message),
-          signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal
+          signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal,
+          redirect: this.redirectMode
         };
-        const response = await fetch(endpoint, init);
+        const response = await this.fetchFn(endpoint.href, init);
         if (response.status === 401 && this.authProvider && !triedAuth) {
           this.resourceMetadataUrl = extractResourceMetadataUrl(response);
           try {
             const result = await auth(this.authProvider, {
               serverUrl: this.url,
-              resourceMetadataUrl: this.resourceMetadataUrl
+              resourceMetadataUrl: this.resourceMetadataUrl,
+              fetchFn: this.fetchFn
             });
             if (result !== "AUTHORIZED") {
               const error = new UnauthorizedError();
@@ -1269,12 +1258,18 @@ var SseMCPTransport = class {
 };
 
 // src/tool/mcp-http-transport.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+import {
+  EventSourceParserStream as EventSourceParserStream2,
+  withUserAgentSuffix as withUserAgentSuffix2,
+  getRuntimeEnvironmentUserAgent as getRuntimeEnvironmentUserAgent2
+} from "@ai-sdk/provider-utils";
 var HttpMCPTransport = class {
   constructor({
     url,
     headers,
-    authProvider
+    authProvider,
+    redirect = "error",
+    fetch: fetchFn
   }) {
     this.inboundReconnectAttempts = 0;
     this.reconnectionOptions = {
@@ -1286,6 +1281,8 @@ var HttpMCPTransport = class {
     this.url = new URL(url);
     this.headers = headers;
     this.authProvider = authProvider;
+    this.redirectMode = redirect;
+    this.fetchFn = fetchFn != null ? fetchFn : globalThis.fetch;
   }
   async commonHeaders(base) {
     const headers = {
@@ -1302,10 +1299,10 @@ var HttpMCPTransport = class {
         headers["Authorization"] = `Bearer ${tokens.access_token}`;
       }
     }
-    return (0, import_provider_utils2.withUserAgentSuffix)(
+    return withUserAgentSuffix2(
       headers,
       `ai-sdk/${VERSION}`,
-      (0, import_provider_utils2.getRuntimeEnvironmentUserAgent)()
+      getRuntimeEnvironmentUserAgent2()
     );
   }
   async start() {
@@ -1323,10 +1320,11 @@ var HttpMCPTransport = class {
     try {
       if (this.sessionId && this.abortController && !this.abortController.signal.aborted) {
         const headers = await this.commonHeaders({});
-        await fetch(this.url, {
+        await this.fetchFn(this.url.href, {
           method: "DELETE",
           headers,
-          signal: this.abortController.signal
+          signal: this.abortController.signal,
+          redirect: this.redirectMode
         }).catch(() => void 0);
       }
     } catch (e) {
@@ -1346,9 +1344,10 @@ var HttpMCPTransport = class {
           method: "POST",
           headers,
           body: JSON.stringify(message),
-          signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal
+          signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal,
+          redirect: this.redirectMode
         };
-        const response = await fetch(this.url, init);
+        const response = await this.fetchFn(this.url.href, init);
         const sessionId = response.headers.get("mcp-session-id");
         if (sessionId) {
           this.sessionId = sessionId;
@@ -1358,7 +1357,8 @@ var HttpMCPTransport = class {
           try {
             const result = await auth(this.authProvider, {
               serverUrl: this.url,
-              resourceMetadataUrl: this.resourceMetadataUrl
+              resourceMetadataUrl: this.resourceMetadataUrl,
+              fetchFn: this.fetchFn
             });
             if (result !== "AUTHORIZED") {
               const error2 = new UnauthorizedError();
@@ -1407,7 +1407,7 @@ var HttpMCPTransport = class {
             (_e = this.onerror) == null ? void 0 : _e.call(this, error2);
             throw error2;
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new import_provider_utils2.EventSourceParserStream());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream2());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a4, _b4, _c2;
@@ -1492,10 +1492,11 @@ var HttpMCPTransport = class {
       if (resumeToken) {
         headers["last-event-id"] = resumeToken;
       }
-      const response = await fetch(this.url.href, {
+      const response = await this.fetchFn(this.url.href, {
         method: "GET",
         headers,
-        signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal
+        signal: (_a3 = this.abortController) == null ? void 0 : _a3.signal,
+        redirect: this.redirectMode
       });
       const sessionId = response.headers.get("mcp-session-id");
       if (sessionId) {
@@ -1506,7 +1507,8 @@ var HttpMCPTransport = class {
         try {
           const result = await auth(this.authProvider, {
             serverUrl: this.url,
-            resourceMetadataUrl: this.resourceMetadataUrl
+            resourceMetadataUrl: this.resourceMetadataUrl,
+            fetchFn: this.fetchFn
           });
           if (result !== "AUTHORIZED") {
             const error = new UnauthorizedError();
@@ -1529,7 +1531,7 @@ var HttpMCPTransport = class {
         (_d = this.onerror) == null ? void 0 : _d.call(this, error);
         return;
       }
-      const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new import_provider_utils2.EventSourceParserStream());
+      const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream2());
       const reader = stream.getReader();
       const processEvents = async () => {
         var _a4, _b4, _c2, _d2;
@@ -1614,7 +1616,7 @@ function mcpToModelOutput({
       }
       if (part.type === "image" && "data" in part && "mimeType" in part) {
         return {
-          type: "image-data",
+          type: "file-data",
           data: part.data,
           mediaType: part.mimeType
         };
@@ -1640,6 +1642,7 @@ var DefaultMCPClient = class {
     this.requestMessageId = 0;
     this.responseHandlers = /* @__PURE__ */ new Map();
     this.serverCapabilities = {};
+    this._serverInfo = { name: "", version: "" };
     this.isClosed = true;
     this.onUncaughtError = onUncaughtError;
     this.clientCapabilities = capabilities != null ? capabilities : {};
@@ -1670,6 +1673,9 @@ var DefaultMCPClient = class {
       version
     };
   }
+  get serverInfo() {
+    return this._serverInfo;
+  }
   async init() {
     try {
       await this.transport.start();
@@ -1696,6 +1702,7 @@ var DefaultMCPClient = class {
         });
       }
       this.serverCapabilities = result.capabilities;
+      this._serverInfo = result.serverInfo;
       await this.notification({
         method: "notifications/initialized"
       });
@@ -1941,22 +1948,25 @@ var DefaultMCPClient = class {
         var _a4;
         (_a4 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a4.throwIfAborted();
         const result = await self.callTool({ name: name3, args, options });
+        if (result.isError) {
+          return result;
+        }
         if (outputSchema != null) {
           return self.extractStructuredContent(result, outputSchema, name3);
         }
         return result;
       };
-      const toolWithExecute = schemas === "automatic" ? (0, import_provider_utils3.dynamicTool)({
+      const toolWithExecute = schemas === "automatic" ? dynamicTool({
         description,
         title: resolvedTitle,
-        inputSchema: (0, import_provider_utils3.jsonSchema)({
+        inputSchema: jsonSchema({
           ...inputSchema,
           properties: (_b3 = inputSchema.properties) != null ? _b3 : {},
           additionalProperties: false
         }),
         execute,
         toModelOutput: mcpToModelOutput
-      }) : (0, import_provider_utils3.tool)({
+      }) : tool({
         description,
         title: resolvedTitle,
         inputSchema: schemas[name3].inputSchema,
@@ -1973,9 +1983,9 @@ var DefaultMCPClient = class {
    */
   async extractStructuredContent(result, outputSchema, toolName) {
     if ("structuredContent" in result && result.structuredContent != null) {
-      const validationResult = await (0, import_provider_utils3.safeValidateTypes)({
+      const validationResult = await safeValidateTypes({
         value: result.structuredContent,
-        schema: (0, import_provider_utils3.asSchema)(outputSchema)
+        schema: asSchema(outputSchema)
       });
       if (!validationResult.success) {
         throw new MCPClientError({
@@ -1988,7 +1998,7 @@ var DefaultMCPClient = class {
     if ("content" in result && Array.isArray(result.content)) {
       const textContent = result.content.find((c) => c.type === "text");
       if (textContent && "text" in textContent) {
-        const parseResult = await (0, import_provider_utils3.safeParseJSON)({
+        const parseResult = await safeParseJSON({
           text: textContent.text,
           schema: outputSchema
         });
@@ -2143,13 +2153,12 @@ var DefaultMCPClient = class {
     );
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   ElicitResultSchema,
   ElicitationRequestSchema,
   UnauthorizedError,
   auth,
   createMCPClient,
-  experimental_createMCPClient
-});
+  createMCPClient as experimental_createMCPClient
+};
 //# sourceMappingURL=index.js.map