@ai-sdk/mcp 2.0.0-beta.24 → 2.0.0-beta.26

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 index_exports = {};
-__export(index_exports, {
-  ElicitResultSchema: () => ElicitResultSchema,
-  ElicitationRequestSchema: () => ElicitationRequestSchema,
-  UnauthorizedError: () => UnauthorizedError,
-  auth: () => auth,
-  createMCPClient: () => createMCPClient,
-  experimental_createMCPClient: () => createMCPClient
-});
-module.exports = __toCommonJS(index_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,230 +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(),
-  title: import_v4.z.optional(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,
@@ -315,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) => {
@@ -344,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,
@@ -441,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 {
@@ -693,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);
@@ -1106,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() {
@@ -1159,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;
@@ -1288,7 +1258,11 @@ 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,
@@ -1325,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() {
@@ -1433,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;
@@ -1557,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;
@@ -1982,17 +1956,17 @@ var DefaultMCPClient = class {
         }
         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,
@@ -2009,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({
@@ -2024,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
         });
@@ -2179,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