@xyd-js/ask-ai-widget 0.0.0-build-87368f8-20251101145203 → 0.0.0-build-1760f84-20251129221538

package/dist/server-standalone.js

@@ -39934,9 +39934,6 @@ var postToApi = async ({
 function tool(tool2) {
   return tool2;
 }
-function dynamicTool(tool2) {
-  return { ...tool2, type: "dynamic" };
-}
 function createProviderDefinedToolFactory({
   id,
   name: name14,
@@ -42042,23 +42039,6 @@ var name53 = "AI_MCPClientError";
 var marker53 = `vercel.ai.error.${name53}`;
 var symbol53 = Symbol.for(marker53);
 var _a53;
-var MCPClientError = class extends AISDKError {
-  constructor({
-    name: name17 = "MCPClientError",
-    message,
-    cause,
-    data,
-    code
-  }) {
-    super({ name: name17, message, cause });
-    this[_a53] = true;
-    this.data = data;
-    this.code = code;
-  }
-  static isInstance(error40) {
-    return AISDKError.hasMarker(error40, marker53);
-  }
-};
 _a53 = symbol53;
 var name63 = "AI_NoImageGeneratedError";
 var marker63 = `vercel.ai.error.${name63}`;
@@ -46446,12 +46426,6 @@ var marker16 = `vercel.ai.error.${name162}`;
 var symbol16 = Symbol.for(marker16);
 var _a16;
 _a16 = symbol16;
-var LATEST_PROTOCOL_VERSION = "2025-06-18";
-var SUPPORTED_PROTOCOL_VERSIONS = [
-  LATEST_PROTOCOL_VERSION,
-  "2025-03-26",
-  "2024-11-05"
-];
 var ClientOrServerImplementationSchema = exports_external.looseObject({
   name: exports_external.string(),
   version: exports_external.string()
@@ -46558,52 +46532,1274 @@ var JSONRPCMessageSchema = exports_external.union([
   JSONRPCResponseSchema,
   JSONRPCErrorSchema
 ]);
-var SseMCPTransport = class {
-  constructor({
-    url: url2,
-    headers
-  }) {
-    this.connected = false;
-    this.url = new URL(url2);
-    this.headers = headers;
+var uiMessagesSchema = lazyValidator(() => zodSchema(exports_external.array(exports_external.object({
+  id: exports_external.string(),
+  role: exports_external.enum(["system", "user", "assistant"]),
+  metadata: exports_external.unknown().optional(),
+  parts: exports_external.array(exports_external.union([
+    exports_external.object({
+      type: exports_external.literal("text"),
+      text: exports_external.string(),
+      state: exports_external.enum(["streaming", "done"]).optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("reasoning"),
+      text: exports_external.string(),
+      state: exports_external.enum(["streaming", "done"]).optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("source-url"),
+      sourceId: exports_external.string(),
+      url: exports_external.string(),
+      title: exports_external.string().optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("source-document"),
+      sourceId: exports_external.string(),
+      mediaType: exports_external.string(),
+      title: exports_external.string(),
+      filename: exports_external.string().optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("file"),
+      mediaType: exports_external.string(),
+      filename: exports_external.string().optional(),
+      url: exports_external.string(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("step-start")
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("data-"),
+      id: exports_external.string().optional(),
+      data: exports_external.unknown()
+    }),
+    exports_external.object({
+      type: exports_external.literal("dynamic-tool"),
+      toolName: exports_external.string(),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("input-streaming"),
+      input: exports_external.unknown().optional(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.never().optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("dynamic-tool"),
+      toolName: exports_external.string(),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("input-available"),
+      input: exports_external.unknown(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("dynamic-tool"),
+      toolName: exports_external.string(),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("output-available"),
+      input: exports_external.unknown(),
+      output: exports_external.unknown(),
+      errorText: exports_external.never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      preliminary: exports_external.boolean().optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("dynamic-tool"),
+      toolName: exports_external.string(),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("output-error"),
+      input: exports_external.unknown(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.string(),
+      callProviderMetadata: providerMetadataSchema.optional()
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("tool-"),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("input-streaming"),
+      providerExecuted: exports_external.boolean().optional(),
+      input: exports_external.unknown().optional(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.never().optional(),
+      approval: exports_external.never().optional()
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("tool-"),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("input-available"),
+      providerExecuted: exports_external.boolean().optional(),
+      input: exports_external.unknown(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: exports_external.never().optional()
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("tool-"),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("approval-requested"),
+      input: exports_external.unknown(),
+      providerExecuted: exports_external.boolean().optional(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: exports_external.object({
+        id: exports_external.string(),
+        approved: exports_external.never().optional(),
+        reason: exports_external.never().optional()
+      })
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("tool-"),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("approval-responded"),
+      input: exports_external.unknown(),
+      providerExecuted: exports_external.boolean().optional(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: exports_external.object({
+        id: exports_external.string(),
+        approved: exports_external.boolean(),
+        reason: exports_external.string().optional()
+      })
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("tool-"),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("output-available"),
+      providerExecuted: exports_external.boolean().optional(),
+      input: exports_external.unknown(),
+      output: exports_external.unknown(),
+      errorText: exports_external.never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      preliminary: exports_external.boolean().optional(),
+      approval: exports_external.object({
+        id: exports_external.string(),
+        approved: exports_external.literal(true),
+        reason: exports_external.string().optional()
+      }).optional()
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("tool-"),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("output-error"),
+      providerExecuted: exports_external.boolean().optional(),
+      input: exports_external.unknown(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.string(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: exports_external.object({
+        id: exports_external.string(),
+        approved: exports_external.literal(true),
+        reason: exports_external.string().optional()
+      }).optional()
+    }),
+    exports_external.object({
+      type: exports_external.string().startsWith("tool-"),
+      toolCallId: exports_external.string(),
+      state: exports_external.literal("output-denied"),
+      providerExecuted: exports_external.boolean().optional(),
+      input: exports_external.unknown(),
+      output: exports_external.never().optional(),
+      errorText: exports_external.never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: exports_external.object({
+        id: exports_external.string(),
+        approved: exports_external.literal(false),
+        reason: exports_external.string().optional()
+      })
+    })
+  ]))
+}))));
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.18_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var createIdGenerator2 = ({
+  prefix,
+  size = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0;i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
+  if (prefix == null) {
+    return generator;
   }
-  async start() {
-    return new Promise((resolve2, reject) => {
-      if (this.connected) {
-        return resolve2();
-      }
-      this.abortController = new AbortController;
-      const establishConnection = async () => {
-        var _a172, _b8, _c;
-        try {
-          const headers = withUserAgentSuffix({
-            ...this.headers,
-            Accept: "text/event-stream"
-          }, `ai-sdk/${VERSION3}`, getRuntimeEnvironmentUserAgent());
-          const response = await fetch(this.url.href, {
-            headers,
-            signal: (_a172 = this.abortController) == null ? undefined : _a172.signal
-          });
-          if (!response.ok || !response.body) {
-            const error40 = new MCPClientError({
-              message: `MCP SSE Transport Error: ${response.status} ${response.statusText}`
-            });
-            (_b8 = this.onerror) == null || _b8.call(this, error40);
-            return reject(error40);
-          }
-          const stream = response.body.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream);
-          const reader = stream.getReader();
-          const processEvents = async () => {
-            var _a18, _b22, _c2;
-            try {
-              while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                  if (this.connected) {
-                    this.connected = false;
-                    throw new MCPClientError({
-                      message: "MCP SSE Transport Error: Connection closed unexpectedly"
-                    });
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return () => `${prefix}${separator}${generator()}`;
+};
+var generateId2 = createIdGenerator2();
+function getRuntimeEnvironmentUserAgent2(globalThisAny = globalThis) {
+  var _a18, _b8, _c;
+  if (globalThisAny.window) {
+    return `runtime/browser`;
+  }
+  if ((_a18 = globalThisAny.navigator) == null ? undefined : _a18.userAgent) {
+    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
+  }
+  if ((_c = (_b8 = globalThisAny.process) == null ? undefined : _b8.versions) == null ? undefined : _c.node) {
+    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
+  }
+  if (globalThisAny.EdgeRuntime) {
+    return `runtime/vercel-edge`;
+  }
+  return "runtime/unknown";
+}
+function normalizeHeaders(headers) {
+  if (headers == null) {
+    return {};
+  }
+  const normalized = {};
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      normalized[key.toLowerCase()] = value;
+    });
+  } else {
+    if (!Array.isArray(headers)) {
+      headers = Object.entries(headers);
+    }
+    for (const [key, value] of headers) {
+      if (value != null) {
+        normalized[key.toLowerCase()] = value;
+      }
+    }
+  }
+  return normalized;
+}
+function withUserAgentSuffix2(headers, ...userAgentSuffixParts) {
+  const normalizedHeaders = new Headers(normalizeHeaders(headers));
+  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
+  normalizedHeaders.set("user-agent", [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" "));
+  return Object.fromEntries(normalizedHeaders.entries());
+}
+var validatorSymbol2 = Symbol.for("vercel.ai.validator");
+function tool2(tool22) {
+  return tool22;
+}
+function dynamicTool(tool22) {
+  return { ...tool22, type: "dynamic" };
+}
+var ignoreOverride2 = Symbol("Let zodToJsonSchema decide on which parser to use");
+var ALPHA_NUMERIC2 = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+var schemaSymbol2 = Symbol.for("vercel.ai.schema");
+function jsonSchema2(jsonSchema22, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol2]: true,
+    _type: undefined,
+    [validatorSymbol2]: true,
+    get jsonSchema() {
+      if (typeof jsonSchema22 === "function") {
+        jsonSchema22 = jsonSchema22();
+      }
+      return jsonSchema22;
+    },
+    validate
+  };
+}
+
+// ../../node_modules/.pnpm/pkce-challenge@5.0.0/node_modules/pkce-challenge/dist/index.node.js
+var crypto;
+crypto = globalThis.crypto?.webcrypto ?? globalThis.crypto ?? import("node:crypto").then((m) => m.webcrypto);
+async function getRandomValues(size) {
+  return (await crypto).getRandomValues(new Uint8Array(size));
+}
+async function random(size) {
+  const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+  let result = "";
+  const randomUints = await getRandomValues(size);
+  for (let i = 0;i < size; i++) {
+    const randomIndex = randomUints[i] % mask.length;
+    result += mask[randomIndex];
+  }
+  return result;
+}
+async function generateVerifier(length) {
+  return await random(length);
+}
+async function generateChallenge(code_verifier) {
+  const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+  return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+async function pkceChallenge(length) {
+  if (!length)
+    length = 43;
+  if (length < 43 || length > 128) {
+    throw `Expected a length between 43 and 128. Received ${length}.`;
+  }
+  const verifier = await generateVerifier(length);
+  const challenge = await generateChallenge(verifier);
+  return {
+    code_verifier: verifier,
+    code_challenge: challenge
+  };
+}
+
+// ../../node_modules/.pnpm/@ai-sdk+mcp@0.0.11_zod@3.25.76/node_modules/@ai-sdk/mcp/dist/index.mjs
+var name17 = "AI_MCPClientError";
+var marker18 = `vercel.ai.error.${name17}`;
+var symbol19 = Symbol.for(marker18);
+var _a18;
+var _b8;
+var MCPClientError = class extends (_b8 = AISDKError, _a18 = symbol19, _b8) {
+  constructor({
+    name: name34 = "MCPClientError",
+    message,
+    cause,
+    data,
+    code
+  }) {
+    super({ name: name34, message, cause });
+    this[_a18] = true;
+    this.data = data;
+    this.code = code;
+  }
+  static isInstance(error40) {
+    return AISDKError.hasMarker(error40, marker18);
+  }
+};
+var LATEST_PROTOCOL_VERSION = "2025-06-18";
+var SUPPORTED_PROTOCOL_VERSIONS = [
+  LATEST_PROTOCOL_VERSION,
+  "2025-03-26",
+  "2024-11-05"
+];
+var ClientOrServerImplementationSchema2 = exports_external.looseObject({
+  name: exports_external.string(),
+  version: exports_external.string()
+});
+var BaseParamsSchema2 = exports_external.looseObject({
+  _meta: exports_external.optional(exports_external.object({}).loose())
+});
+var ResultSchema2 = BaseParamsSchema2;
+var RequestSchema2 = exports_external.object({
+  method: exports_external.string(),
+  params: exports_external.optional(BaseParamsSchema2)
+});
+var ElicitationCapabilitySchema = exports_external.object({
+  applyDefaults: exports_external.optional(exports_external.boolean())
+}).loose();
+var ServerCapabilitiesSchema2 = exports_external.looseObject({
+  experimental: exports_external.optional(exports_external.object({}).loose()),
+  logging: exports_external.optional(exports_external.object({}).loose()),
+  prompts: exports_external.optional(exports_external.looseObject({
+    listChanged: exports_external.optional(exports_external.boolean())
+  })),
+  resources: exports_external.optional(exports_external.looseObject({
+    subscribe: exports_external.optional(exports_external.boolean()),
+    listChanged: exports_external.optional(exports_external.boolean())
+  })),
+  tools: exports_external.optional(exports_external.looseObject({
+    listChanged: exports_external.optional(exports_external.boolean())
+  })),
+  elicitation: exports_external.optional(ElicitationCapabilitySchema)
+});
+var ClientCapabilitiesSchema = exports_external.object({
+  elicitation: exports_external.optional(ElicitationCapabilitySchema)
+}).loose();
+var InitializeResultSchema2 = ResultSchema2.extend({
+  protocolVersion: exports_external.string(),
+  capabilities: ServerCapabilitiesSchema2,
+  serverInfo: ClientOrServerImplementationSchema2,
+  instructions: exports_external.optional(exports_external.string())
+});
+var PaginatedResultSchema2 = ResultSchema2.extend({
+  nextCursor: exports_external.optional(exports_external.string())
+});
+var ToolSchema2 = exports_external.object({
+  name: exports_external.string(),
+  description: exports_external.optional(exports_external.string()),
+  inputSchema: exports_external.object({
+    type: exports_external.literal("object"),
+    properties: exports_external.optional(exports_external.object({}).loose())
+  }).loose()
+}).loose();
+var ListToolsResultSchema2 = PaginatedResultSchema2.extend({
+  tools: exports_external.array(ToolSchema2)
+});
+var TextContentSchema2 = exports_external.object({
+  type: exports_external.literal("text"),
+  text: exports_external.string()
+}).loose();
+var ImageContentSchema2 = exports_external.object({
+  type: exports_external.literal("image"),
+  data: exports_external.base64(),
+  mimeType: exports_external.string()
+}).loose();
+var ResourceSchema = exports_external.object({
+  uri: exports_external.string(),
+  name: exports_external.string(),
+  title: exports_external.optional(exports_external.string()),
+  description: exports_external.optional(exports_external.string()),
+  mimeType: exports_external.optional(exports_external.string()),
+  size: exports_external.optional(exports_external.number())
+}).loose();
+var ListResourcesResultSchema = PaginatedResultSchema2.extend({
+  resources: exports_external.array(ResourceSchema)
+});
+var ResourceContentsSchema2 = exports_external.object({
+  uri: exports_external.string(),
+  name: exports_external.optional(exports_external.string()),
+  title: exports_external.optional(exports_external.string()),
+  mimeType: exports_external.optional(exports_external.string())
+}).loose();
+var TextResourceContentsSchema2 = ResourceContentsSchema2.extend({
+  text: exports_external.string()
+});
+var BlobResourceContentsSchema2 = ResourceContentsSchema2.extend({
+  blob: exports_external.base64()
+});
+var EmbeddedResourceSchema2 = exports_external.object({
+  type: exports_external.literal("resource"),
+  resource: exports_external.union([TextResourceContentsSchema2, BlobResourceContentsSchema2])
+}).loose();
+var CallToolResultSchema2 = ResultSchema2.extend({
+  content: exports_external.array(exports_external.union([TextContentSchema2, ImageContentSchema2, EmbeddedResourceSchema2])),
+  isError: exports_external.boolean().default(false).optional()
+}).or(ResultSchema2.extend({
+  toolResult: exports_external.unknown()
+}));
+var ResourceTemplateSchema = exports_external.object({
+  uriTemplate: exports_external.string(),
+  name: exports_external.string(),
+  title: exports_external.optional(exports_external.string()),
+  description: exports_external.optional(exports_external.string()),
+  mimeType: exports_external.optional(exports_external.string())
+}).loose();
+var ListResourceTemplatesResultSchema = ResultSchema2.extend({
+  resourceTemplates: exports_external.array(ResourceTemplateSchema)
+});
+var ReadResourceResultSchema = ResultSchema2.extend({
+  contents: exports_external.array(exports_external.union([TextResourceContentsSchema2, BlobResourceContentsSchema2]))
+});
+var PromptArgumentSchema = exports_external.object({
+  name: exports_external.string(),
+  description: exports_external.optional(exports_external.string()),
+  required: exports_external.optional(exports_external.boolean())
+}).loose();
+var PromptSchema = exports_external.object({
+  name: exports_external.string(),
+  title: exports_external.optional(exports_external.string()),
+  description: exports_external.optional(exports_external.string()),
+  arguments: exports_external.optional(exports_external.array(PromptArgumentSchema))
+}).loose();
+var ListPromptsResultSchema = PaginatedResultSchema2.extend({
+  prompts: exports_external.array(PromptSchema)
+});
+var PromptMessageSchema = exports_external.object({
+  role: exports_external.union([exports_external.literal("user"), exports_external.literal("assistant")]),
+  content: exports_external.union([
+    TextContentSchema2,
+    ImageContentSchema2,
+    EmbeddedResourceSchema2
+  ])
+}).loose();
+var GetPromptResultSchema = ResultSchema2.extend({
+  description: exports_external.optional(exports_external.string()),
+  messages: exports_external.array(PromptMessageSchema)
+});
+var ElicitationRequestParamsSchema = BaseParamsSchema2.extend({
+  message: exports_external.string(),
+  requestedSchema: exports_external.unknown()
+});
+var ElicitationRequestSchema = RequestSchema2.extend({
+  method: exports_external.literal("elicitation/create"),
+  params: ElicitationRequestParamsSchema
+});
+var ElicitResultSchema = ResultSchema2.extend({
+  action: exports_external.union([
+    exports_external.literal("accept"),
+    exports_external.literal("decline"),
+    exports_external.literal("cancel")
+  ]),
+  content: exports_external.optional(exports_external.record(exports_external.string(), exports_external.unknown()))
+});
+var JSONRPC_VERSION2 = "2.0";
+var JSONRPCRequestSchema2 = exports_external.object({
+  jsonrpc: exports_external.literal(JSONRPC_VERSION2),
+  id: exports_external.union([exports_external.string(), exports_external.number().int()])
+}).merge(RequestSchema2).strict();
+var JSONRPCResponseSchema2 = exports_external.object({
+  jsonrpc: exports_external.literal(JSONRPC_VERSION2),
+  id: exports_external.union([exports_external.string(), exports_external.number().int()]),
+  result: ResultSchema2
+}).strict();
+var JSONRPCErrorSchema2 = exports_external.object({
+  jsonrpc: exports_external.literal(JSONRPC_VERSION2),
+  id: exports_external.union([exports_external.string(), exports_external.number().int()]),
+  error: exports_external.object({
+    code: exports_external.number().int(),
+    message: exports_external.string(),
+    data: exports_external.optional(exports_external.unknown())
+  })
+}).strict();
+var JSONRPCNotificationSchema2 = exports_external.object({
+  jsonrpc: exports_external.literal(JSONRPC_VERSION2)
+}).merge(exports_external.object({
+  method: exports_external.string(),
+  params: exports_external.optional(BaseParamsSchema2)
+})).strict();
+var JSONRPCMessageSchema2 = exports_external.union([
+  JSONRPCRequestSchema2,
+  JSONRPCNotificationSchema2,
+  JSONRPCResponseSchema2,
+  JSONRPCErrorSchema2
+]);
+var VERSION4 = typeof __PACKAGE_VERSION__ !== "undefined" ? __PACKAGE_VERSION__ : "0.0.0-test";
+var OAuthTokensSchema = exports_external.object({
+  access_token: exports_external.string(),
+  id_token: exports_external.string().optional(),
+  token_type: exports_external.string(),
+  expires_in: exports_external.number().optional(),
+  scope: exports_external.string().optional(),
+  refresh_token: exports_external.string().optional()
+}).strip();
+var SafeUrlSchema = exports_external.string().url().superRefine((val, ctx) => {
+  if (!URL.canParse(val)) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "URL must be parseable",
+      fatal: true
+    });
+    return exports_external.NEVER;
+  }
+}).refine((url2) => {
+  const u = new URL(url2);
+  return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
+}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
+var OAuthProtectedResourceMetadataSchema = exports_external.object({
+  resource: exports_external.string().url(),
+  authorization_servers: exports_external.array(SafeUrlSchema).optional(),
+  jwks_uri: exports_external.string().url().optional(),
+  scopes_supported: exports_external.array(exports_external.string()).optional(),
+  bearer_methods_supported: exports_external.array(exports_external.string()).optional(),
+  resource_signing_alg_values_supported: exports_external.array(exports_external.string()).optional(),
+  resource_name: exports_external.string().optional(),
+  resource_documentation: exports_external.string().optional(),
+  resource_policy_uri: exports_external.string().url().optional(),
+  resource_tos_uri: exports_external.string().url().optional(),
+  tls_client_certificate_bound_access_tokens: exports_external.boolean().optional(),
+  authorization_details_types_supported: exports_external.array(exports_external.string()).optional(),
+  dpop_signing_alg_values_supported: exports_external.array(exports_external.string()).optional(),
+  dpop_bound_access_tokens_required: exports_external.boolean().optional()
+}).passthrough();
+var OAuthMetadataSchema = exports_external.object({
+  issuer: exports_external.string(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: exports_external.array(exports_external.string()).optional(),
+  response_types_supported: exports_external.array(exports_external.string()),
+  grant_types_supported: exports_external.array(exports_external.string()).optional(),
+  code_challenge_methods_supported: exports_external.array(exports_external.string()),
+  token_endpoint_auth_methods_supported: exports_external.array(exports_external.string()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: exports_external.array(exports_external.string()).optional()
+}).passthrough();
+var OpenIdProviderMetadataSchema = exports_external.object({
+  issuer: exports_external.string(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  userinfo_endpoint: SafeUrlSchema.optional(),
+  jwks_uri: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: exports_external.array(exports_external.string()).optional(),
+  response_types_supported: exports_external.array(exports_external.string()),
+  grant_types_supported: exports_external.array(exports_external.string()).optional(),
+  subject_types_supported: exports_external.array(exports_external.string()),
+  id_token_signing_alg_values_supported: exports_external.array(exports_external.string()),
+  claims_supported: exports_external.array(exports_external.string()).optional(),
+  token_endpoint_auth_methods_supported: exports_external.array(exports_external.string()).optional()
+}).passthrough();
+var OpenIdProviderDiscoveryMetadataSchema = OpenIdProviderMetadataSchema.merge(OAuthMetadataSchema.pick({
+  code_challenge_methods_supported: true
+}));
+var OAuthClientInformationSchema = exports_external.object({
+  client_id: exports_external.string(),
+  client_secret: exports_external.string().optional(),
+  client_id_issued_at: exports_external.number().optional(),
+  client_secret_expires_at: exports_external.number().optional()
+}).strip();
+var OAuthClientMetadataSchema = exports_external.object({
+  redirect_uris: exports_external.array(SafeUrlSchema),
+  token_endpoint_auth_method: exports_external.string().optional(),
+  grant_types: exports_external.array(exports_external.string()).optional(),
+  response_types: exports_external.array(exports_external.string()).optional(),
+  client_name: exports_external.string().optional(),
+  client_uri: SafeUrlSchema.optional(),
+  logo_uri: SafeUrlSchema.optional(),
+  scope: exports_external.string().optional(),
+  contacts: exports_external.array(exports_external.string()).optional(),
+  tos_uri: SafeUrlSchema.optional(),
+  policy_uri: exports_external.string().optional(),
+  jwks_uri: SafeUrlSchema.optional(),
+  jwks: exports_external.any().optional(),
+  software_id: exports_external.string().optional(),
+  software_version: exports_external.string().optional(),
+  software_statement: exports_external.string().optional()
+}).strip();
+var OAuthErrorResponseSchema = exports_external.object({
+  error: exports_external.string(),
+  error_description: exports_external.string().optional(),
+  error_uri: exports_external.string().optional()
+});
+var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
+var name24 = "AI_MCPClientOAuthError";
+var marker24 = `vercel.ai.error.${name24}`;
+var symbol24 = Symbol.for(marker24);
+var _a24;
+var _b22;
+var MCPClientOAuthError = class extends (_b22 = AISDKError, _a24 = symbol24, _b22) {
+  constructor({
+    name: name34 = "MCPClientOAuthError",
+    message,
+    cause
+  }) {
+    super({ name: name34, message, cause });
+    this[_a24] = true;
+  }
+  static isInstance(error40) {
+    return AISDKError.hasMarker(error40, marker24);
+  }
+};
+var ServerError = class extends MCPClientOAuthError {
+};
+ServerError.errorCode = "server_error";
+var InvalidClientError = class extends MCPClientOAuthError {
+};
+InvalidClientError.errorCode = "invalid_client";
+var InvalidGrantError = class extends MCPClientOAuthError {
+};
+InvalidGrantError.errorCode = "invalid_grant";
+var UnauthorizedClientError = class extends MCPClientOAuthError {
+};
+UnauthorizedClientError.errorCode = "unauthorized_client";
+var OAUTH_ERRORS = {
+  [ServerError.errorCode]: ServerError,
+  [InvalidClientError.errorCode]: InvalidClientError,
+  [InvalidGrantError.errorCode]: InvalidGrantError,
+  [UnauthorizedClientError.errorCode]: UnauthorizedClientError
+};
+function resourceUrlFromServerUrl(url2) {
+  const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href);
+  resourceURL.hash = "";
+  return resourceURL;
+}
+function checkResourceAllowed({
+  requestedResource,
+  configuredResource
+}) {
+  const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
+  const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
+  if (requested.origin !== configured.origin) {
+    return false;
+  }
+  if (requested.pathname.length < configured.pathname.length) {
+    return false;
+  }
+  const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
+  const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
+  return requestedPath.startsWith(configuredPath);
+}
+var UnauthorizedError = class extends Error {
+  constructor(message = "Unauthorized") {
+    super(message);
+    this.name = "UnauthorizedError";
+  }
+};
+function extractResourceMetadataUrl(response) {
+  var _a34;
+  const header = (_a34 = response.headers.get("www-authenticate")) != null ? _a34 : response.headers.get("WWW-Authenticate");
+  if (!header) {
+    return;
+  }
+  const [type, scheme] = header.split(" ");
+  if (type.toLowerCase() !== "bearer" || !scheme) {
+    return;
+  }
+  const regex = /resource_metadata="([^"]*)"/;
+  const match = header.match(regex);
+  if (!match) {
+    return;
+  }
+  try {
+    return new URL(match[1]);
+  } catch (e) {
+    return;
+  }
+}
+function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
+}
+async function fetchWithCorsRetry(url2, headers, fetchFn = fetch) {
+  try {
+    return await fetchFn(url2, { headers });
+  } catch (error40) {
+    if (error40 instanceof TypeError) {
+      if (headers) {
+        return fetchWithCorsRetry(url2, undefined, fetchFn);
+      } else {
+        return;
+      }
+    }
+    throw error40;
+  }
+}
+async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion
+  };
+  return await fetchWithCorsRetry(url2, headers, fetchFn);
+}
+function shouldAttemptFallback(response, pathname) {
+  return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
+}
+async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
+  var _a34, _b32;
+  const issuer = new URL(serverUrl);
+  const protocolVersion = (_a34 = opts == null ? undefined : opts.protocolVersion) != null ? _a34 : LATEST_PROTOCOL_VERSION;
+  let url2;
+  if (opts == null ? undefined : opts.metadataUrl) {
+    url2 = new URL(opts.metadataUrl);
+  } else {
+    const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
+    url2 = new URL(wellKnownPath, (_b32 = opts == null ? undefined : opts.metadataServerUrl) != null ? _b32 : issuer);
+    url2.search = issuer.search;
+  }
+  let response = await tryMetadataDiscovery(url2, protocolVersion, fetchFn);
+  if (!(opts == null ? undefined : opts.metadataUrl) && shouldAttemptFallback(response, issuer.pathname)) {
+    const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer);
+    response = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn);
+  }
+  return response;
+}
+async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
+  const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+    protocolVersion: opts == null ? undefined : opts.protocolVersion,
+    metadataUrl: opts == null ? undefined : opts.resourceMetadataUrl
+  });
+  if (!response || response.status === 404) {
+    throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
+  }
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
+  }
+  return OAuthProtectedResourceMetadataSchema.parse(await response.json());
+}
+function buildDiscoveryUrls(authorizationServerUrl) {
+  const url2 = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
+  const hasPath = url2.pathname !== "/";
+  const urlsToTry = [];
+  if (!hasPath) {
+    urlsToTry.push({
+      url: new URL("/.well-known/oauth-authorization-server", url2.origin),
+      type: "oauth"
+    });
+    urlsToTry.push({
+      url: new URL("/.well-known/openid-configuration", url2.origin),
+      type: "oidc"
+    });
+    return urlsToTry;
+  }
+  let pathname = url2.pathname;
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  urlsToTry.push({
+    url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url2.origin),
+    type: "oauth"
+  });
+  urlsToTry.push({
+    url: new URL("/.well-known/oauth-authorization-server", url2.origin),
+    type: "oauth"
+  });
+  urlsToTry.push({
+    url: new URL(`/.well-known/openid-configuration${pathname}`, url2.origin),
+    type: "oidc"
+  });
+  urlsToTry.push({
+    url: new URL(`${pathname}/.well-known/openid-configuration`, url2.origin),
+    type: "oidc"
+  });
+  return urlsToTry;
+}
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, {
+  fetchFn = fetch,
+  protocolVersion = LATEST_PROTOCOL_VERSION
+} = {}) {
+  var _a34;
+  const headers = { "MCP-Protocol-Version": protocolVersion };
+  const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
+  for (const { url: endpointUrl, type } of urlsToTry) {
+    const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+    if (!response) {
+      continue;
+    }
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 500) {
+        continue;
+      }
+      throw new Error(`HTTP ${response.status} trying to load ${type === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+    }
+    if (type === "oauth") {
+      return OAuthMetadataSchema.parse(await response.json());
+    } else {
+      const metadata = OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+      if (!((_a34 = metadata.code_challenge_methods_supported) == null ? undefined : _a34.includes("S256"))) {
+        throw new Error(`Incompatible OIDC provider at ${endpointUrl}: does not support S256 code challenge method required by MCP specification`);
+      }
+      return metadata;
+    }
+  }
+  return;
+}
+async function startAuthorization(authorizationServerUrl, {
+  metadata,
+  clientInformation,
+  redirectUrl,
+  scope,
+  state,
+  resource
+}) {
+  const responseType = "code";
+  const codeChallengeMethod = "S256";
+  let authorizationUrl;
+  if (metadata) {
+    authorizationUrl = new URL(metadata.authorization_endpoint);
+    if (!metadata.response_types_supported.includes(responseType)) {
+      throw new Error(`Incompatible auth server: does not support response type ${responseType}`);
+    }
+    if (!metadata.code_challenge_methods_supported || !metadata.code_challenge_methods_supported.includes(codeChallengeMethod)) {
+      throw new Error(`Incompatible auth server: does not support code challenge method ${codeChallengeMethod}`);
+    }
+  } else {
+    authorizationUrl = new URL("/authorize", authorizationServerUrl);
+  }
+  const challenge = await pkceChallenge();
+  const codeVerifier = challenge.code_verifier;
+  const codeChallenge = challenge.code_challenge;
+  authorizationUrl.searchParams.set("response_type", responseType);
+  authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+  authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+  authorizationUrl.searchParams.set("code_challenge_method", codeChallengeMethod);
+  authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+  if (state) {
+    authorizationUrl.searchParams.set("state", state);
+  }
+  if (scope) {
+    authorizationUrl.searchParams.set("scope", scope);
+  }
+  if (scope == null ? undefined : scope.includes("offline_access")) {
+    authorizationUrl.searchParams.append("prompt", "consent");
+  }
+  if (resource) {
+    authorizationUrl.searchParams.set("resource", resource.href);
+  }
+  return { authorizationUrl, codeVerifier };
+}
+function selectClientAuthMethod(clientInformation, supportedMethods) {
+  const hasClientSecret = clientInformation.client_secret !== undefined;
+  if (supportedMethods.length === 0) {
+    return hasClientSecret ? "client_secret_post" : "none";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_basic")) {
+    return "client_secret_basic";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_post")) {
+    return "client_secret_post";
+  }
+  if (supportedMethods.includes("none")) {
+    return "none";
+  }
+  return hasClientSecret ? "client_secret_post" : "none";
+}
+function applyClientAuthentication(method, clientInformation, headers, params) {
+  const { client_id, client_secret } = clientInformation;
+  switch (method) {
+    case "client_secret_basic":
+      applyBasicAuth(client_id, client_secret, headers);
+      return;
+    case "client_secret_post":
+      applyPostAuth(client_id, client_secret, params);
+      return;
+    case "none":
+      applyPublicAuth(client_id, params);
+      return;
+    default:
+      throw new Error(`Unsupported client authentication method: ${method}`);
+  }
+}
+function applyBasicAuth(clientId, clientSecret, headers) {
+  if (!clientSecret) {
+    throw new Error("client_secret_basic authentication requires a client_secret");
+  }
+  const credentials = btoa(`${clientId}:${clientSecret}`);
+  headers.set("Authorization", `Basic ${credentials}`);
+}
+function applyPostAuth(clientId, clientSecret, params) {
+  params.set("client_id", clientId);
+  if (clientSecret) {
+    params.set("client_secret", clientSecret);
+  }
+}
+function applyPublicAuth(clientId, params) {
+  params.set("client_id", clientId);
+}
+async function parseErrorResponse(input) {
+  const statusCode = input instanceof Response ? input.status : undefined;
+  const body = input instanceof Response ? await input.text() : input;
+  try {
+    const result = OAuthErrorResponseSchema.parse(JSON.parse(body));
+    const { error: error40, error_description, error_uri } = result;
+    const errorClass = OAUTH_ERRORS[error40] || ServerError;
+    return new errorClass({
+      message: error_description || "",
+      cause: error_uri
+    });
+  } catch (error40) {
+    const errorMessage = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error40}. Raw body: ${body}`;
+    return new ServerError({ message: errorMessage });
+  }
+}
+async function exchangeAuthorization(authorizationServerUrl, {
+  metadata,
+  clientInformation,
+  authorizationCode,
+  codeVerifier,
+  redirectUri,
+  resource,
+  addClientAuthentication,
+  fetchFn
+}) {
+  var _a34;
+  const grantType = "authorization_code";
+  const tokenUrl = (metadata == null ? undefined : metadata.token_endpoint) ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
+  if ((metadata == null ? undefined : metadata.grant_types_supported) && !metadata.grant_types_supported.includes(grantType)) {
+    throw new Error(`Incompatible auth server: does not support grant type ${grantType}`);
+  }
+  const headers = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  });
+  const params = new URLSearchParams({
+    grant_type: grantType,
+    code: authorizationCode,
+    code_verifier: codeVerifier,
+    redirect_uri: String(redirectUri)
+  });
+  if (addClientAuthentication) {
+    addClientAuthentication(headers, params, authorizationServerUrl, metadata);
+  } else {
+    const supportedMethods = (_a34 = metadata == null ? undefined : metadata.token_endpoint_auth_methods_supported) != null ? _a34 : [];
+    const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
+    applyClientAuthentication(authMethod, clientInformation, headers, params);
+  }
+  if (resource) {
+    params.set("resource", resource.href);
+  }
+  const response = await (fetchFn != null ? fetchFn : fetch)(tokenUrl, {
+    method: "POST",
+    headers,
+    body: params
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthTokensSchema.parse(await response.json());
+}
+async function refreshAuthorization(authorizationServerUrl, {
+  metadata,
+  clientInformation,
+  refreshToken,
+  resource,
+  addClientAuthentication,
+  fetchFn
+}) {
+  var _a34;
+  const grantType = "refresh_token";
+  let tokenUrl;
+  if (metadata) {
+    tokenUrl = new URL(metadata.token_endpoint);
+    if (metadata.grant_types_supported && !metadata.grant_types_supported.includes(grantType)) {
+      throw new Error(`Incompatible auth server: does not support grant type ${grantType}`);
+    }
+  } else {
+    tokenUrl = new URL("/token", authorizationServerUrl);
+  }
+  const headers = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded"
+  });
+  const params = new URLSearchParams({
+    grant_type: grantType,
+    refresh_token: refreshToken
+  });
+  if (addClientAuthentication) {
+    addClientAuthentication(headers, params, authorizationServerUrl, metadata);
+  } else {
+    const supportedMethods = (_a34 = metadata == null ? undefined : metadata.token_endpoint_auth_methods_supported) != null ? _a34 : [];
+    const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
+    applyClientAuthentication(authMethod, clientInformation, headers, params);
+  }
+  if (resource) {
+    params.set("resource", resource.href);
+  }
+  const response = await (fetchFn != null ? fetchFn : fetch)(tokenUrl, {
+    method: "POST",
+    headers,
+    body: params
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthTokensSchema.parse({
+    refresh_token: refreshToken,
+    ...await response.json()
+  });
+}
+async function registerClient(authorizationServerUrl, {
+  metadata,
+  clientMetadata,
+  fetchFn
+}) {
+  let registrationUrl;
+  if (metadata) {
+    if (!metadata.registration_endpoint) {
+      throw new Error("Incompatible auth server: does not support dynamic client registration");
+    }
+    registrationUrl = new URL(metadata.registration_endpoint);
+  } else {
+    registrationUrl = new URL("/register", authorizationServerUrl);
+  }
+  const response = await (fetchFn != null ? fetchFn : fetch)(registrationUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(clientMetadata)
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthClientInformationFullSchema.parse(await response.json());
+}
+async function auth(provider, options) {
+  var _a34, _b32;
+  try {
+    return await authInternal(provider, options);
+  } catch (error40) {
+    if (error40 instanceof InvalidClientError || error40 instanceof UnauthorizedClientError) {
+      await ((_a34 = provider.invalidateCredentials) == null ? undefined : _a34.call(provider, "all"));
+      return await authInternal(provider, options);
+    } else if (error40 instanceof InvalidGrantError) {
+      await ((_b32 = provider.invalidateCredentials) == null ? undefined : _b32.call(provider, "tokens"));
+      return await authInternal(provider, options);
+    }
+    throw error40;
+  }
+}
+async function selectResourceURL(serverUrl, provider, resourceMetadata) {
+  const defaultResource = resourceUrlFromServerUrl(serverUrl);
+  if (provider.validateResourceURL) {
+    return await provider.validateResourceURL(defaultResource, resourceMetadata == null ? undefined : resourceMetadata.resource);
+  }
+  if (!resourceMetadata) {
+    return;
+  }
+  if (!checkResourceAllowed({
+    requestedResource: defaultResource,
+    configuredResource: resourceMetadata.resource
+  })) {
+    throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
+  }
+  return new URL(resourceMetadata.resource);
+}
+async function authInternal(provider, {
+  serverUrl,
+  authorizationCode,
+  scope,
+  resourceMetadataUrl,
+  fetchFn
+}) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl }, fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch (e) {}
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = serverUrl;
+  }
+  const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+  const metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
+    fetchFn
+  });
+  let clientInformation = await Promise.resolve(provider.clientInformation());
+  if (!clientInformation) {
+    if (authorizationCode !== undefined) {
+      throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+    }
+    if (!provider.saveClientInformation) {
+      throw new Error("OAuth client information must be saveable for dynamic registration");
+    }
+    const fullInformation = await registerClient(authorizationServerUrl, {
+      metadata,
+      clientMetadata: provider.clientMetadata,
+      fetchFn
+    });
+    await provider.saveClientInformation(fullInformation);
+    clientInformation = fullInformation;
+  }
+  if (authorizationCode !== undefined) {
+    const codeVerifier2 = await provider.codeVerifier();
+    const tokens2 = await exchangeAuthorization(authorizationServerUrl, {
+      metadata,
+      clientInformation,
+      authorizationCode,
+      codeVerifier: codeVerifier2,
+      redirectUri: provider.redirectUrl,
+      resource,
+      addClientAuthentication: provider.addClientAuthentication,
+      fetchFn
+    });
+    await provider.saveTokens(tokens2);
+    return "AUTHORIZED";
+  }
+  const tokens = await provider.tokens();
+  if (tokens == null ? undefined : tokens.refresh_token) {
+    try {
+      const newTokens = await refreshAuthorization(authorizationServerUrl, {
+        metadata,
+        clientInformation,
+        refreshToken: tokens.refresh_token,
+        resource,
+        addClientAuthentication: provider.addClientAuthentication,
+        fetchFn
+      });
+      await provider.saveTokens(newTokens);
+      return "AUTHORIZED";
+    } catch (error40) {
+      if (!(error40 instanceof MCPClientOAuthError) || error40 instanceof ServerError) {} else {
+        throw error40;
+      }
+    }
+  }
+  const state = provider.state ? await provider.state() : undefined;
+  const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
+    metadata,
+    clientInformation,
+    state,
+    redirectUrl: provider.redirectUrl,
+    scope: scope || provider.clientMetadata.scope,
+    resource
+  });
+  await provider.saveCodeVerifier(codeVerifier);
+  await provider.redirectToAuthorization(authorizationUrl);
+  return "REDIRECT";
+}
+var SseMCPTransport = class {
+  constructor({
+    url: url2,
+    headers,
+    authProvider
+  }) {
+    this.connected = false;
+    this.url = new URL(url2);
+    this.headers = headers;
+    this.authProvider = authProvider;
+  }
+  async commonHeaders(base) {
+    const headers = {
+      ...this.headers,
+      ...base,
+      "mcp-protocol-version": LATEST_PROTOCOL_VERSION
+    };
+    if (this.authProvider) {
+      const tokens = await this.authProvider.tokens();
+      if (tokens == null ? undefined : tokens.access_token) {
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+      }
+    }
+    return withUserAgentSuffix2(headers, `ai-sdk/${VERSION4}`, getRuntimeEnvironmentUserAgent2());
+  }
+  async start() {
+    return new Promise((resolve2, reject) => {
+      if (this.connected) {
+        return resolve2();
+      }
+      this.abortController = new AbortController;
+      const establishConnection = async (triedAuth = false) => {
+        var _a34, _b32, _c, _d, _e;
+        try {
+          const headers = await this.commonHeaders({
+            Accept: "text/event-stream"
+          });
+          const response = await fetch(this.url.href, {
+            headers,
+            signal: (_a34 = this.abortController) == null ? undefined : _a34.signal
+          });
+          if (response.status === 401 && this.authProvider && !triedAuth) {
+            this.resourceMetadataUrl = extractResourceMetadataUrl(response);
+            try {
+              const result = await auth(this.authProvider, {
+                serverUrl: this.url,
+                resourceMetadataUrl: this.resourceMetadataUrl
+              });
+              if (result !== "AUTHORIZED") {
+                const error40 = new UnauthorizedError;
+                (_b32 = this.onerror) == null || _b32.call(this, error40);
+                return reject(error40);
+              }
+            } catch (error40) {
+              (_c = this.onerror) == null || _c.call(this, error40);
+              return reject(error40);
+            }
+            return establishConnection(true);
+          }
+          if (!response.ok || !response.body) {
+            let errorMessage = `MCP SSE Transport Error: ${response.status} ${response.statusText}`;
+            if (response.status === 405) {
+              errorMessage += ". This server does not support SSE transport. Try using `http` transport instead";
+            }
+            const error40 = new MCPClientError({
+              message: errorMessage
+            });
+            (_d = this.onerror) == null || _d.call(this, error40);
+            return reject(error40);
+          }
+          const stream = response.body.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream);
+          const reader = stream.getReader();
+          const processEvents = async () => {
+            var _a44, _b42, _c2;
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                  if (this.connected) {
+                    this.connected = false;
+                    throw new MCPClientError({
+                      message: "MCP SSE Transport Error: Connection closed unexpectedly"
+                    });
                   }
                   return;
                 }
@@ -46619,14 +47815,14 @@ var SseMCPTransport = class {
                   resolve2();
                 } else if (event === "message") {
                   try {
-                    const message = JSONRPCMessageSchema.parse(JSON.parse(data));
-                    (_a18 = this.onmessage) == null || _a18.call(this, message);
+                    const message = JSONRPCMessageSchema2.parse(JSON.parse(data));
+                    (_a44 = this.onmessage) == null || _a44.call(this, message);
                   } catch (error40) {
                     const e = new MCPClientError({
                       message: "MCP SSE Transport Error: Failed to parse message",
                       cause: error40
                     });
-                    (_b22 = this.onerror) == null || _b22.call(this, e);
+                    (_b42 = this.onerror) == null || _b42.call(this, e);
                   }
                 }
               }
@@ -46646,7 +47842,7 @@ var SseMCPTransport = class {
           if (error40 instanceof Error && error40.name === "AbortError") {
             return;
           }
-          (_c = this.onerror) == null || _c.call(this, error40);
+          (_e = this.onerror) == null || _e.call(this, error40);
           reject(error40);
         }
       };
@@ -46654,52 +47850,377 @@ var SseMCPTransport = class {
     });
   }
   async close() {
-    var _a172, _b8, _c;
+    var _a34, _b32, _c;
     this.connected = false;
-    (_a172 = this.sseConnection) == null || _a172.close();
-    (_b8 = this.abortController) == null || _b8.abort();
+    (_a34 = this.sseConnection) == null || _a34.close();
+    (_b32 = this.abortController) == null || _b32.abort();
     (_c = this.onclose) == null || _c.call(this);
   }
   async send(message) {
-    var _a172, _b8, _c;
     if (!this.endpoint || !this.connected) {
       throw new MCPClientError({
         message: "MCP SSE Transport Error: Not connected"
       });
     }
+    const endpoint = this.endpoint;
+    const attempt = async (triedAuth = false) => {
+      var _a34, _b32, _c, _d, _e;
+      try {
+        const headers = await this.commonHeaders({
+          "Content-Type": "application/json"
+        });
+        const init = {
+          method: "POST",
+          headers,
+          body: JSON.stringify(message),
+          signal: (_a34 = this.abortController) == null ? undefined : _a34.signal
+        };
+        const response = await fetch(endpoint, 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
+            });
+            if (result !== "AUTHORIZED") {
+              const error40 = new UnauthorizedError;
+              (_b32 = this.onerror) == null || _b32.call(this, error40);
+              return;
+            }
+          } catch (error40) {
+            (_c = this.onerror) == null || _c.call(this, error40);
+            return;
+          }
+          return attempt(true);
+        }
+        if (!response.ok) {
+          const text2 = await response.text().catch(() => null);
+          const error40 = new MCPClientError({
+            message: `MCP SSE Transport Error: POSTing to endpoint (HTTP ${response.status}): ${text2}`
+          });
+          (_d = this.onerror) == null || _d.call(this, error40);
+          return;
+        }
+      } catch (error40) {
+        (_e = this.onerror) == null || _e.call(this, error40);
+        return;
+      }
+    };
+    await attempt();
+  }
+};
+var HttpMCPTransport = class {
+  constructor({
+    url: url2,
+    headers,
+    authProvider
+  }) {
+    this.inboundReconnectAttempts = 0;
+    this.reconnectionOptions = {
+      initialReconnectionDelay: 1000,
+      maxReconnectionDelay: 30000,
+      reconnectionDelayGrowFactor: 1.5,
+      maxRetries: 2
+    };
+    this.url = new URL(url2);
+    this.headers = headers;
+    this.authProvider = authProvider;
+  }
+  async commonHeaders(base) {
+    const headers = {
+      ...this.headers,
+      ...base,
+      "mcp-protocol-version": LATEST_PROTOCOL_VERSION
+    };
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    if (this.authProvider) {
+      const tokens = await this.authProvider.tokens();
+      if (tokens == null ? undefined : tokens.access_token) {
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+      }
+    }
+    return withUserAgentSuffix2(headers, `ai-sdk/${VERSION4}`, getRuntimeEnvironmentUserAgent2());
+  }
+  async start() {
+    if (this.abortController) {
+      throw new MCPClientError({
+        message: "MCP HTTP Transport Error: Transport already started. Note: client.connect() calls start() automatically."
+      });
+    }
+    this.abortController = new AbortController;
+    this.openInboundSse();
+  }
+  async close() {
+    var _a34, _b32, _c;
+    (_a34 = this.inboundSseConnection) == null || _a34.close();
     try {
-      const headers = withUserAgentSuffix({
-        ...this.headers,
-        "Content-Type": "application/json"
-      }, `ai-sdk/${VERSION3}`, getRuntimeEnvironmentUserAgent());
-      const init = {
-        method: "POST",
+      if (this.sessionId && this.abortController && !this.abortController.signal.aborted) {
+        const headers = await this.commonHeaders({});
+        await fetch(this.url, {
+          method: "DELETE",
+          headers,
+          signal: this.abortController.signal
+        }).catch(() => {
+          return;
+        });
+      }
+    } catch (e) {}
+    (_b32 = this.abortController) == null || _b32.abort();
+    (_c = this.onclose) == null || _c.call(this);
+  }
+  async send(message) {
+    const attempt = async (triedAuth = false) => {
+      var _a34, _b32, _c, _d, _e, _f, _g;
+      try {
+        const headers = await this.commonHeaders({
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream"
+        });
+        const init = {
+          method: "POST",
+          headers,
+          body: JSON.stringify(message),
+          signal: (_a34 = this.abortController) == null ? undefined : _a34.signal
+        };
+        const response = await fetch(this.url, init);
+        const sessionId = response.headers.get("mcp-session-id");
+        if (sessionId) {
+          this.sessionId = sessionId;
+        }
+        if (response.status === 401 && this.authProvider && !triedAuth) {
+          this.resourceMetadataUrl = extractResourceMetadataUrl(response);
+          try {
+            const result = await auth(this.authProvider, {
+              serverUrl: this.url,
+              resourceMetadataUrl: this.resourceMetadataUrl
+            });
+            if (result !== "AUTHORIZED") {
+              const error210 = new UnauthorizedError;
+              throw error210;
+            }
+          } catch (error210) {
+            (_b32 = this.onerror) == null || _b32.call(this, error210);
+            throw error210;
+          }
+          return attempt(true);
+        }
+        if (response.status === 202) {
+          if (!this.inboundSseConnection) {
+            this.openInboundSse();
+          }
+          return;
+        }
+        if (!response.ok) {
+          const text2 = await response.text().catch(() => null);
+          let errorMessage = `MCP HTTP Transport Error: POSTing to endpoint (HTTP ${response.status}): ${text2}`;
+          if (response.status === 404) {
+            errorMessage += ". This server does not support HTTP transport. Try using `sse` transport instead";
+          }
+          const error210 = new MCPClientError({
+            message: errorMessage
+          });
+          (_c = this.onerror) == null || _c.call(this, error210);
+          throw error210;
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          const data = await response.json();
+          const messages = Array.isArray(data) ? data.map((m) => JSONRPCMessageSchema2.parse(m)) : [JSONRPCMessageSchema2.parse(data)];
+          for (const m of messages)
+            (_d = this.onmessage) == null || _d.call(this, m);
+          return;
+        }
+        if (contentType.includes("text/event-stream")) {
+          if (!response.body) {
+            const error210 = new MCPClientError({
+              message: "MCP HTTP Transport Error: text/event-stream response without body"
+            });
+            (_e = this.onerror) == null || _e.call(this, error210);
+            throw error210;
+          }
+          const stream = response.body.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream);
+          const reader = stream.getReader();
+          const processEvents = async () => {
+            var _a44, _b42, _c2;
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  return;
+                const { event, data } = value;
+                if (event === "message") {
+                  try {
+                    const msg = JSONRPCMessageSchema2.parse(JSON.parse(data));
+                    (_a44 = this.onmessage) == null || _a44.call(this, msg);
+                  } catch (error210) {
+                    const e = new MCPClientError({
+                      message: "MCP HTTP Transport Error: Failed to parse message",
+                      cause: error210
+                    });
+                    (_b42 = this.onerror) == null || _b42.call(this, e);
+                  }
+                }
+              }
+            } catch (error210) {
+              if (error210 instanceof Error && error210.name === "AbortError") {
+                return;
+              }
+              (_c2 = this.onerror) == null || _c2.call(this, error210);
+            }
+          };
+          processEvents();
+          return;
+        }
+        const error40 = new MCPClientError({
+          message: `MCP HTTP Transport Error: Unexpected content type: ${contentType}`
+        });
+        (_f = this.onerror) == null || _f.call(this, error40);
+        throw error40;
+      } catch (error40) {
+        (_g = this.onerror) == null || _g.call(this, error40);
+        throw error40;
+      }
+    };
+    await attempt();
+  }
+  getNextReconnectionDelay(attempt) {
+    const {
+      initialReconnectionDelay,
+      reconnectionDelayGrowFactor,
+      maxReconnectionDelay
+    } = this.reconnectionOptions;
+    return Math.min(initialReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, attempt), maxReconnectionDelay);
+  }
+  scheduleInboundSseReconnection() {
+    var _a34;
+    const { maxRetries } = this.reconnectionOptions;
+    if (maxRetries > 0 && this.inboundReconnectAttempts >= maxRetries) {
+      (_a34 = this.onerror) == null || _a34.call(this, new MCPClientError({
+        message: `MCP HTTP Transport Error: Maximum reconnection attempts (${maxRetries}) exceeded.`
+      }));
+      return;
+    }
+    const delay2 = this.getNextReconnectionDelay(this.inboundReconnectAttempts);
+    this.inboundReconnectAttempts += 1;
+    setTimeout(async () => {
+      var _a44;
+      if ((_a44 = this.abortController) == null ? undefined : _a44.signal.aborted)
+        return;
+      await this.openInboundSse(false, this.lastInboundEventId);
+    }, delay2);
+  }
+  async openInboundSse(triedAuth = false, resumeToken) {
+    var _a34, _b32, _c, _d, _e, _f;
+    try {
+      const headers = await this.commonHeaders({
+        Accept: "text/event-stream"
+      });
+      if (resumeToken) {
+        headers["last-event-id"] = resumeToken;
+      }
+      const response = await fetch(this.url.href, {
+        method: "GET",
         headers,
-        body: JSON.stringify(message),
-        signal: (_a172 = this.abortController) == null ? undefined : _a172.signal
-      };
-      const response = await fetch(this.endpoint, init);
-      if (!response.ok) {
-        const text2 = await response.text().catch(() => null);
+        signal: (_a34 = this.abortController) == null ? undefined : _a34.signal
+      });
+      const sessionId = response.headers.get("mcp-session-id");
+      if (sessionId) {
+        this.sessionId = sessionId;
+      }
+      if (response.status === 401 && this.authProvider && !triedAuth) {
+        this.resourceMetadataUrl = extractResourceMetadataUrl(response);
+        try {
+          const result = await auth(this.authProvider, {
+            serverUrl: this.url,
+            resourceMetadataUrl: this.resourceMetadataUrl
+          });
+          if (result !== "AUTHORIZED") {
+            const error40 = new UnauthorizedError;
+            (_b32 = this.onerror) == null || _b32.call(this, error40);
+            return;
+          }
+        } catch (error40) {
+          (_c = this.onerror) == null || _c.call(this, error40);
+          return;
+        }
+        return this.openInboundSse(true, resumeToken);
+      }
+      if (response.status === 405) {
+        return;
+      }
+      if (!response.ok || !response.body) {
         const error40 = new MCPClientError({
-          message: `MCP SSE Transport Error: POSTing to endpoint (HTTP ${response.status}): ${text2}`
+          message: `MCP HTTP Transport Error: GET SSE failed: ${response.status} ${response.statusText}`
         });
-        (_b8 = this.onerror) == null || _b8.call(this, error40);
+        (_d = this.onerror) == null || _d.call(this, error40);
         return;
       }
+      const stream = response.body.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream);
+      const reader = stream.getReader();
+      const processEvents = async () => {
+        var _a44, _b42, _c2, _d2;
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              return;
+            const { event, data, id } = value;
+            if (id) {
+              this.lastInboundEventId = id;
+            }
+            if (event === "message") {
+              try {
+                const msg = JSONRPCMessageSchema2.parse(JSON.parse(data));
+                (_a44 = this.onmessage) == null || _a44.call(this, msg);
+              } catch (error40) {
+                const e = new MCPClientError({
+                  message: "MCP HTTP Transport Error: Failed to parse message",
+                  cause: error40
+                });
+                (_b42 = this.onerror) == null || _b42.call(this, e);
+              }
+            }
+          }
+        } catch (error40) {
+          if (error40 instanceof Error && error40.name === "AbortError") {
+            return;
+          }
+          (_c2 = this.onerror) == null || _c2.call(this, error40);
+          if (!((_d2 = this.abortController) == null ? undefined : _d2.signal.aborted)) {
+            this.scheduleInboundSseReconnection();
+          }
+        }
+      };
+      this.inboundSseConnection = {
+        close: () => reader.cancel()
+      };
+      this.inboundReconnectAttempts = 0;
+      processEvents();
     } catch (error40) {
-      (_c = this.onerror) == null || _c.call(this, error40);
-      return;
+      if (error40 instanceof Error && error40.name === "AbortError") {
+        return;
+      }
+      (_e = this.onerror) == null || _e.call(this, error40);
+      if (!((_f = this.abortController) == null ? undefined : _f.signal.aborted)) {
+        this.scheduleInboundSseReconnection();
+      }
     }
   }
 };
 function createMcpTransport(config2) {
-  if (config2.type !== "sse") {
-    throw new MCPClientError({
-      message: "Unsupported or invalid transport configuration. If you are using a custom transport, make sure it implements the MCPTransport interface."
-    });
+  switch (config2.type) {
+    case "sse":
+      return new SseMCPTransport(config2);
+    case "http":
+      return new HttpMCPTransport(config2);
+    default:
+      throw new MCPClientError({
+        message: "Unsupported or invalid transport configuration. If you are using a custom transport, make sure it implements the MCPTransport interface."
+      });
   }
-  return new SseMCPTransport(config2);
 }
 function isCustomMcpTransport(transport) {
   return "start" in transport && typeof transport.start === "function" && "send" in transport && typeof transport.send === "function" && "close" in transport && typeof transport.close === "function";
@@ -46713,14 +48234,17 @@ async function createMCPClient(config2) {
 var DefaultMCPClient = class {
   constructor({
     transport: transportConfig,
-    name: name17 = "ai-sdk-mcp-client",
-    onUncaughtError
+    name: name34 = "ai-sdk-mcp-client",
+    version: version2 = CLIENT_VERSION,
+    onUncaughtError,
+    capabilities
   }) {
     this.requestMessageId = 0;
     this.responseHandlers = /* @__PURE__ */ new Map;
     this.serverCapabilities = {};
     this.isClosed = true;
     this.onUncaughtError = onUncaughtError;
+    this.clientCapabilities = capabilities != null ? capabilities : {};
     if (isCustomMcpTransport(transportConfig)) {
       this.transport = transportConfig;
     } else {
@@ -46730,16 +48254,20 @@ var DefaultMCPClient = class {
     this.transport.onerror = (error40) => this.onError(error40);
     this.transport.onmessage = (message) => {
       if ("method" in message) {
-        this.onError(new MCPClientError({
-          message: "Unsupported message type"
-        }));
+        if ("id" in message) {
+          this.onRequestMessage(message);
+        } else {
+          this.onError(new MCPClientError({
+            message: "Unsupported message type"
+          }));
+        }
         return;
       }
       this.onResponse(message);
     };
     this.clientInfo = {
-      name: name17,
-      version: CLIENT_VERSION
+      name: name34,
+      version: version2
     };
   }
   async init() {
@@ -46751,11 +48279,11 @@ var DefaultMCPClient = class {
           method: "initialize",
           params: {
             protocolVersion: LATEST_PROTOCOL_VERSION,
-            capabilities: {},
+            capabilities: this.clientCapabilities,
             clientInfo: this.clientInfo
           }
         },
-        resultSchema: InitializeResultSchema
+        resultSchema: InitializeResultSchema2
       });
       if (result === undefined) {
         throw new MCPClientError({
@@ -46778,10 +48306,10 @@ var DefaultMCPClient = class {
     }
   }
   async close() {
-    var _a172;
+    var _a34;
     if (this.isClosed)
       return;
-    await ((_a172 = this.transport) == null ? undefined : _a172.close());
+    await ((_a34 = this.transport) == null ? undefined : _a34.close());
     this.onClose();
   }
   assertCapability(method) {
@@ -46796,6 +48324,23 @@ var DefaultMCPClient = class {
           });
         }
         break;
+      case "resources/list":
+      case "resources/read":
+      case "resources/templates/list":
+        if (!this.serverCapabilities.resources) {
+          throw new MCPClientError({
+            message: `Server does not support resources`
+          });
+        }
+        break;
+      case "prompts/list":
+      case "prompts/get":
+        if (!this.serverCapabilities.prompts) {
+          throw new MCPClientError({
+            message: `Server does not support prompts`
+          });
+        }
+        break;
       default:
         throw new MCPClientError({
           message: `Unsupported method: ${method}`
@@ -46859,7 +48404,7 @@ var DefaultMCPClient = class {
     try {
       return this.request({
         request: { method: "tools/list", params },
-        resultSchema: ListToolsResultSchema,
+        resultSchema: ListToolsResultSchema2,
         options
       });
     } catch (error40) {
@@ -46867,14 +48412,14 @@ var DefaultMCPClient = class {
     }
   }
   async callTool({
-    name: name17,
+    name: name34,
     args,
     options
   }) {
     try {
       return this.request({
-        request: { method: "tools/call", params: { name: name17, arguments: args } },
-        resultSchema: CallToolResultSchema,
+        request: { method: "tools/call", params: { name: name34, arguments: args } },
+        resultSchema: CallToolResultSchema2,
         options: {
           signal: options == null ? undefined : options.abortSignal
         }
@@ -46883,6 +48428,76 @@ var DefaultMCPClient = class {
       throw error40;
     }
   }
+  async listResourcesInternal({
+    params,
+    options
+  } = {}) {
+    try {
+      return this.request({
+        request: { method: "resources/list", params },
+        resultSchema: ListResourcesResultSchema,
+        options
+      });
+    } catch (error40) {
+      throw error40;
+    }
+  }
+  async readResourceInternal({
+    uri,
+    options
+  }) {
+    try {
+      return this.request({
+        request: { method: "resources/read", params: { uri } },
+        resultSchema: ReadResourceResultSchema,
+        options
+      });
+    } catch (error40) {
+      throw error40;
+    }
+  }
+  async listResourceTemplatesInternal({
+    options
+  } = {}) {
+    try {
+      return this.request({
+        request: { method: "resources/templates/list" },
+        resultSchema: ListResourceTemplatesResultSchema,
+        options
+      });
+    } catch (error40) {
+      throw error40;
+    }
+  }
+  async listPromptsInternal({
+    params,
+    options
+  } = {}) {
+    try {
+      return this.request({
+        request: { method: "prompts/list", params },
+        resultSchema: ListPromptsResultSchema,
+        options
+      });
+    } catch (error40) {
+      throw error40;
+    }
+  }
+  async getPromptInternal({
+    name: name34,
+    args,
+    options
+  }) {
+    try {
+      return this.request({
+        request: { method: "prompts/get", params: { name: name34, arguments: args } },
+        resultSchema: GetPromptResultSchema,
+        options
+      });
+    } catch (error40) {
+      throw error40;
+    }
+  }
   async notification(notification) {
     const jsonrpcNotification = {
       ...notification,
@@ -46893,38 +48508,139 @@ var DefaultMCPClient = class {
   async tools({
     schemas: schemas3 = "automatic"
   } = {}) {
-    var _a172;
+    var _a34;
     const tools = {};
     try {
-      const listToolsResult = await this.listTools();
-      for (const { name: name17, description, inputSchema } of listToolsResult.tools) {
-        if (schemas3 !== "automatic" && !(name17 in schemas3)) {
-          continue;
-        }
-        const self = this;
-        const execute = async (args, options) => {
-          var _a18;
-          (_a18 = options == null ? undefined : options.abortSignal) == null || _a18.throwIfAborted();
-          return self.callTool({ name: name17, args, options });
-        };
-        const toolWithExecute = schemas3 === "automatic" ? dynamicTool({
-          description,
-          inputSchema: jsonSchema({
-            ...inputSchema,
-            properties: (_a172 = inputSchema.properties) != null ? _a172 : {},
-            additionalProperties: false
-          }),
-          execute
-        }) : tool({
-          description,
-          inputSchema: schemas3[name17].inputSchema,
-          execute
+      const listToolsResult = await this.listTools();
+      for (const { name: name34, description, inputSchema } of listToolsResult.tools) {
+        if (schemas3 !== "automatic" && !(name34 in schemas3)) {
+          continue;
+        }
+        const self = this;
+        const execute = async (args, options) => {
+          var _a44;
+          (_a44 = options == null ? undefined : options.abortSignal) == null || _a44.throwIfAborted();
+          return self.callTool({ name: name34, args, options });
+        };
+        const toolWithExecute = schemas3 === "automatic" ? dynamicTool({
+          description,
+          inputSchema: jsonSchema2({
+            ...inputSchema,
+            properties: (_a34 = inputSchema.properties) != null ? _a34 : {},
+            additionalProperties: false
+          }),
+          execute
+        }) : tool2({
+          description,
+          inputSchema: schemas3[name34].inputSchema,
+          execute
+        });
+        tools[name34] = toolWithExecute;
+      }
+      return tools;
+    } catch (error40) {
+      throw error40;
+    }
+  }
+  listResources({
+    params,
+    options
+  } = {}) {
+    return this.listResourcesInternal({ params, options });
+  }
+  readResource({
+    uri,
+    options
+  }) {
+    return this.readResourceInternal({ uri, options });
+  }
+  listResourceTemplates({
+    options
+  } = {}) {
+    return this.listResourceTemplatesInternal({ options });
+  }
+  listPrompts({
+    params,
+    options
+  } = {}) {
+    return this.listPromptsInternal({ params, options });
+  }
+  getPrompt({
+    name: name34,
+    arguments: args,
+    options
+  }) {
+    return this.getPromptInternal({ name: name34, args, options });
+  }
+  onElicitationRequest(schema, handler) {
+    if (schema !== ElicitationRequestSchema) {
+      throw new MCPClientError({
+        message: "Unsupported request schema. Only ElicitationRequestSchema is supported."
+      });
+    }
+    this.elicitationRequestHandler = handler;
+  }
+  async onRequestMessage(request) {
+    try {
+      if (request.method !== "elicitation/create") {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32601,
+            message: `Unsupported request method: ${request.method}`
+          }
         });
-        tools[name17] = toolWithExecute;
+        return;
+      }
+      if (!this.elicitationRequestHandler) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32601,
+            message: "No elicitation handler registered on client"
+          }
+        });
+        return;
+      }
+      const parsedRequest = ElicitationRequestSchema.safeParse({
+        method: request.method,
+        params: request.params
+      });
+      if (!parsedRequest.success) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32602,
+            message: `Invalid elicitation request: ${parsedRequest.error.message}`,
+            data: parsedRequest.error.issues
+          }
+        });
+        return;
+      }
+      try {
+        const result = await this.elicitationRequestHandler(parsedRequest.data);
+        const validatedResult = ElicitResultSchema.parse(result);
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          result: validatedResult
+        });
+      } catch (error40) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32603,
+            message: error40 instanceof Error ? error40.message : "Failed to handle elicitation request"
+          }
+        });
+        this.onError(error40);
       }
-      return tools;
     } catch (error40) {
-      throw error40;
+      this.onError(error40);
     }
   }
   onClose() {
@@ -46961,192 +48677,6 @@ var DefaultMCPClient = class {
     }));
   }
 };
-var uiMessagesSchema = lazyValidator(() => zodSchema(exports_external.array(exports_external.object({
-  id: exports_external.string(),
-  role: exports_external.enum(["system", "user", "assistant"]),
-  metadata: exports_external.unknown().optional(),
-  parts: exports_external.array(exports_external.union([
-    exports_external.object({
-      type: exports_external.literal("text"),
-      text: exports_external.string(),
-      state: exports_external.enum(["streaming", "done"]).optional(),
-      providerMetadata: providerMetadataSchema.optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("reasoning"),
-      text: exports_external.string(),
-      state: exports_external.enum(["streaming", "done"]).optional(),
-      providerMetadata: providerMetadataSchema.optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("source-url"),
-      sourceId: exports_external.string(),
-      url: exports_external.string(),
-      title: exports_external.string().optional(),
-      providerMetadata: providerMetadataSchema.optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("source-document"),
-      sourceId: exports_external.string(),
-      mediaType: exports_external.string(),
-      title: exports_external.string(),
-      filename: exports_external.string().optional(),
-      providerMetadata: providerMetadataSchema.optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("file"),
-      mediaType: exports_external.string(),
-      filename: exports_external.string().optional(),
-      url: exports_external.string(),
-      providerMetadata: providerMetadataSchema.optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("step-start")
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("data-"),
-      id: exports_external.string().optional(),
-      data: exports_external.unknown()
-    }),
-    exports_external.object({
-      type: exports_external.literal("dynamic-tool"),
-      toolName: exports_external.string(),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("input-streaming"),
-      input: exports_external.unknown().optional(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.never().optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("dynamic-tool"),
-      toolName: exports_external.string(),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("input-available"),
-      input: exports_external.unknown(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.never().optional(),
-      callProviderMetadata: providerMetadataSchema.optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("dynamic-tool"),
-      toolName: exports_external.string(),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("output-available"),
-      input: exports_external.unknown(),
-      output: exports_external.unknown(),
-      errorText: exports_external.never().optional(),
-      callProviderMetadata: providerMetadataSchema.optional(),
-      preliminary: exports_external.boolean().optional()
-    }),
-    exports_external.object({
-      type: exports_external.literal("dynamic-tool"),
-      toolName: exports_external.string(),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("output-error"),
-      input: exports_external.unknown(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.string(),
-      callProviderMetadata: providerMetadataSchema.optional()
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("tool-"),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("input-streaming"),
-      providerExecuted: exports_external.boolean().optional(),
-      input: exports_external.unknown().optional(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.never().optional(),
-      approval: exports_external.never().optional()
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("tool-"),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("input-available"),
-      providerExecuted: exports_external.boolean().optional(),
-      input: exports_external.unknown(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.never().optional(),
-      callProviderMetadata: providerMetadataSchema.optional(),
-      approval: exports_external.never().optional()
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("tool-"),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("approval-requested"),
-      input: exports_external.unknown(),
-      providerExecuted: exports_external.boolean().optional(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.never().optional(),
-      callProviderMetadata: providerMetadataSchema.optional(),
-      approval: exports_external.object({
-        id: exports_external.string(),
-        approved: exports_external.never().optional(),
-        reason: exports_external.never().optional()
-      })
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("tool-"),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("approval-responded"),
-      input: exports_external.unknown(),
-      providerExecuted: exports_external.boolean().optional(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.never().optional(),
-      callProviderMetadata: providerMetadataSchema.optional(),
-      approval: exports_external.object({
-        id: exports_external.string(),
-        approved: exports_external.boolean(),
-        reason: exports_external.string().optional()
-      })
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("tool-"),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("output-available"),
-      providerExecuted: exports_external.boolean().optional(),
-      input: exports_external.unknown(),
-      output: exports_external.unknown(),
-      errorText: exports_external.never().optional(),
-      callProviderMetadata: providerMetadataSchema.optional(),
-      preliminary: exports_external.boolean().optional(),
-      approval: exports_external.object({
-        id: exports_external.string(),
-        approved: exports_external.literal(true),
-        reason: exports_external.string().optional()
-      }).optional()
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("tool-"),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("output-error"),
-      providerExecuted: exports_external.boolean().optional(),
-      input: exports_external.unknown(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.string(),
-      callProviderMetadata: providerMetadataSchema.optional(),
-      approval: exports_external.object({
-        id: exports_external.string(),
-        approved: exports_external.literal(true),
-        reason: exports_external.string().optional()
-      }).optional()
-    }),
-    exports_external.object({
-      type: exports_external.string().startsWith("tool-"),
-      toolCallId: exports_external.string(),
-      state: exports_external.literal("output-denied"),
-      providerExecuted: exports_external.boolean().optional(),
-      input: exports_external.unknown(),
-      output: exports_external.never().optional(),
-      errorText: exports_external.never().optional(),
-      callProviderMetadata: providerMetadataSchema.optional(),
-      approval: exports_external.object({
-        id: exports_external.string(),
-        approved: exports_external.literal(false),
-        reason: exports_external.string().optional()
-      })
-    })
-  ]))
-}))));
 
 // ../xyd-ask-ai/dist/_rollupPluginBabelHelpers-B0vHBMb8.js
 function t(t2, r) {
@@ -47472,45 +49002,8 @@ function g(t2) {
   }, g(t2);
 }
 
-// ../../node_modules/.pnpm/pkce-challenge@5.0.0/node_modules/pkce-challenge/dist/index.node.js
-var crypto;
-crypto = globalThis.crypto?.webcrypto ?? globalThis.crypto ?? import("node:crypto").then((m2) => m2.webcrypto);
-async function getRandomValues(size) {
-  return (await crypto).getRandomValues(new Uint8Array(size));
-}
-async function random(size) {
-  const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
-  let result = "";
-  const randomUints = await getRandomValues(size);
-  for (let i2 = 0;i2 < size; i2++) {
-    const randomIndex = randomUints[i2] % mask.length;
-    result += mask[randomIndex];
-  }
-  return result;
-}
-async function generateVerifier(length) {
-  return await random(length);
-}
-async function generateChallenge(code_verifier) {
-  const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
-  return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
-}
-async function pkceChallenge(length) {
-  if (!length)
-    length = 43;
-  if (length < 43 || length > 128) {
-    throw `Expected a length between 43 and 128. Received ${length}.`;
-  }
-  const verifier = await generateVerifier(length);
-  const challenge = await generateChallenge(verifier);
-  return {
-    code_verifier: verifier,
-    code_challenge: challenge
-  };
-}
-
 // ../../node_modules/.pnpm/@ai-sdk+anthropic@2.0.30_zod@3.25.76/node_modules/@ai-sdk/anthropic/dist/index.mjs
-var VERSION4 = "2.0.30";
+var VERSION5 = "2.0.30";
 var anthropicErrorDataSchema = lazySchema(() => zodSchema(exports_external.object({
   type: exports_external.literal("error"),
   error: exports_external.object({
@@ -47948,9 +49441,9 @@ var anthropicProviderOptions = exports_external.object({
   }).optional()
 });
 function getCacheControl(providerMetadata) {
-  var _a18;
+  var _a19;
   const anthropic2 = providerMetadata == null ? undefined : providerMetadata.anthropic;
-  const cacheControlValue = (_a18 = anthropic2 == null ? undefined : anthropic2.cacheControl) != null ? _a18 : anthropic2 == null ? undefined : anthropic2.cache_control;
+  const cacheControlValue = (_a19 = anthropic2 == null ? undefined : anthropic2.cacheControl) != null ? _a19 : anthropic2 == null ? undefined : anthropic2.cache_control;
   return cacheControlValue;
 }
 var textEditor_20250728ArgsSchema = lazySchema(() => zodSchema(exports_external.object({
@@ -48057,20 +49550,20 @@ async function prepareTools({
     return { tools: undefined, toolChoice: undefined, toolWarnings, betas };
   }
   const anthropicTools2 = [];
-  for (const tool2 of tools) {
-    switch (tool2.type) {
+  for (const tool3 of tools) {
+    switch (tool3.type) {
       case "function": {
-        const cacheControl = getCacheControl(tool2.providerOptions);
+        const cacheControl = getCacheControl(tool3.providerOptions);
         anthropicTools2.push({
-          name: tool2.name,
-          description: tool2.description,
-          input_schema: tool2.inputSchema,
+          name: tool3.name,
+          description: tool3.description,
+          input_schema: tool3.inputSchema,
           cache_control: cacheControl
         });
         break;
       }
       case "provider-defined": {
-        switch (tool2.id) {
+        switch (tool3.id) {
           case "anthropic.code_execution_20250522": {
             betas.add("code-execution-2025-05-22");
             anthropicTools2.push({
@@ -48092,9 +49585,9 @@ async function prepareTools({
             anthropicTools2.push({
               name: "computer",
               type: "computer_20250124",
-              display_width_px: tool2.args.displayWidthPx,
-              display_height_px: tool2.args.displayHeightPx,
-              display_number: tool2.args.displayNumber
+              display_width_px: tool3.args.displayWidthPx,
+              display_height_px: tool3.args.displayHeightPx,
+              display_number: tool3.args.displayNumber
             });
             break;
           }
@@ -48103,9 +49596,9 @@ async function prepareTools({
             anthropicTools2.push({
               name: "computer",
               type: "computer_20241022",
-              display_width_px: tool2.args.displayWidthPx,
-              display_height_px: tool2.args.displayHeightPx,
-              display_number: tool2.args.displayNumber
+              display_width_px: tool3.args.displayWidthPx,
+              display_height_px: tool3.args.displayHeightPx,
+              display_number: tool3.args.displayNumber
             });
             break;
           }
@@ -48135,7 +49628,7 @@ async function prepareTools({
           }
           case "anthropic.text_editor_20250728": {
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: textEditor_20250728ArgsSchema
             });
             anthropicTools2.push({
@@ -48172,7 +49665,7 @@ async function prepareTools({
           case "anthropic.web_fetch_20250910": {
             betas.add("web-fetch-2025-09-10");
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: webFetch_20250910ArgsSchema
             });
             anthropicTools2.push({
@@ -48188,7 +49681,7 @@ async function prepareTools({
           }
           case "anthropic.web_search_20250305": {
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: webSearch_20250305ArgsSchema
             });
             anthropicTools2.push({
@@ -48202,14 +49695,14 @@ async function prepareTools({
             break;
           }
           default: {
-            toolWarnings.push({ type: "unsupported-tool", tool: tool2 });
+            toolWarnings.push({ type: "unsupported-tool", tool: tool3 });
             break;
           }
         }
         break;
       }
       default: {
-        toolWarnings.push({ type: "unsupported-tool", tool: tool2 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool3 });
         break;
       }
     }
@@ -48379,19 +49872,19 @@ async function convertToAnthropicMessagesPrompt({
   sendReasoning,
   warnings
 }) {
-  var _a18, _b8, _c, _d, _e;
+  var _a19, _b9, _c, _d, _e;
   const betas = /* @__PURE__ */ new Set;
   const blocks = groupIntoBlocks(prompt);
   let system = undefined;
   const messages = [];
   async function shouldEnableCitations(providerMetadata) {
-    var _a24, _b22;
+    var _a25, _b23;
     const anthropicOptions = await parseProviderOptions({
       provider: "anthropic",
       providerOptions: providerMetadata,
       schema: anthropicFilePartProviderOptions
     });
-    return (_b22 = (_a24 = anthropicOptions == null ? undefined : anthropicOptions.citations) == null ? undefined : _a24.enabled) != null ? _b22 : false;
+    return (_b23 = (_a25 = anthropicOptions == null ? undefined : anthropicOptions.citations) == null ? undefined : _a25.enabled) != null ? _b23 : false;
   }
   async function getDocumentMetadata(providerMetadata) {
     const anthropicOptions = await parseProviderOptions({
@@ -48431,7 +49924,7 @@ async function convertToAnthropicMessagesPrompt({
               for (let j2 = 0;j2 < content.length; j2++) {
                 const part = content[j2];
                 const isLastPart = j2 === content.length - 1;
-                const cacheControl = (_a18 = getCacheControl(part.providerOptions)) != null ? _a18 : isLastPart ? getCacheControl(message.providerOptions) : undefined;
+                const cacheControl = (_a19 = getCacheControl(part.providerOptions)) != null ? _a19 : isLastPart ? getCacheControl(message.providerOptions) : undefined;
                 switch (part.type) {
                   case "text": {
                     anthropicContent.push({
@@ -48469,7 +49962,7 @@ async function convertToAnthropicMessagesPrompt({
                           media_type: "application/pdf",
                           data: convertToBase64(part.data)
                         },
-                        title: (_b8 = metadata.title) != null ? _b8 : part.filename,
+                        title: (_b9 = metadata.title) != null ? _b9 : part.filename,
                         ...metadata.context && { context: metadata.context },
                         ...enableCitations && {
                           citations: { enabled: true }
@@ -48882,7 +50375,7 @@ function mapAnthropicStopReason({
   }
 }
 function createCitationSource(citation, citationDocuments, generateId3) {
-  var _a18;
+  var _a19;
   if (citation.type !== "page_location" && citation.type !== "char_location") {
     return;
   }
@@ -48895,7 +50388,7 @@ function createCitationSource(citation, citationDocuments, generateId3) {
     sourceType: "document",
     id: generateId3(),
     mediaType: documentInfo.mediaType,
-    title: (_a18 = citation.document_title) != null ? _a18 : documentInfo.title,
+    title: (_a19 = citation.document_title) != null ? _a19 : documentInfo.title,
     filename: documentInfo.filename,
     providerMetadata: {
       anthropic: citation.type === "page_location" ? {
@@ -48913,10 +50406,10 @@ function createCitationSource(citation, citationDocuments, generateId3) {
 var AnthropicMessagesLanguageModel = class {
   constructor(modelId, config2) {
     this.specificationVersion = "v2";
-    var _a18;
+    var _a19;
     this.modelId = modelId;
     this.config = config2;
-    this.generateId = (_a18 = config2.generateId) != null ? _a18 : generateId;
+    this.generateId = (_a19 = config2.generateId) != null ? _a19 : generateId;
   }
   supportsUrl(url2) {
     return url2.protocol === "https:";
@@ -48925,8 +50418,8 @@ var AnthropicMessagesLanguageModel = class {
     return this.config.provider;
   }
   get supportedUrls() {
-    var _a18, _b8, _c;
-    return (_c = (_b8 = (_a18 = this.config).supportedUrls) == null ? undefined : _b8.call(_a18)) != null ? _c : {};
+    var _a19, _b9, _c;
+    return (_c = (_b9 = (_a19 = this.config).supportedUrls) == null ? undefined : _b9.call(_a19)) != null ? _c : {};
   }
   async getArgs({
     prompt,
@@ -48943,7 +50436,7 @@ var AnthropicMessagesLanguageModel = class {
     toolChoice,
     providerOptions
   }) {
-    var _a18, _b8, _c;
+    var _a19, _b9, _c;
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({
@@ -48991,10 +50484,10 @@ var AnthropicMessagesLanguageModel = class {
     });
     const { prompt: messagesPrompt, betas: messagesBetas } = await convertToAnthropicMessagesPrompt({
       prompt,
-      sendReasoning: (_a18 = anthropicOptions == null ? undefined : anthropicOptions.sendReasoning) != null ? _a18 : true,
+      sendReasoning: (_a19 = anthropicOptions == null ? undefined : anthropicOptions.sendReasoning) != null ? _a19 : true,
       warnings
     });
-    const isThinking = ((_b8 = anthropicOptions == null ? undefined : anthropicOptions.thinking) == null ? undefined : _b8.type) === "enabled";
+    const isThinking = ((_b9 = anthropicOptions == null ? undefined : anthropicOptions.thinking) == null ? undefined : _b9.type) === "enabled";
     const thinkingBudget = (_c = anthropicOptions == null ? undefined : anthropicOptions.thinking) == null ? undefined : _c.budgetTokens;
     const baseArgs = {
       model: this.modelId,
@@ -49073,38 +50566,38 @@ var AnthropicMessagesLanguageModel = class {
     return combineHeaders(await resolve(this.config.headers), betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {}, headers);
   }
   buildRequestUrl(isStreaming) {
-    var _a18, _b8, _c;
-    return (_c = (_b8 = (_a18 = this.config).buildRequestUrl) == null ? undefined : _b8.call(_a18, this.config.baseURL, isStreaming)) != null ? _c : `${this.config.baseURL}/messages`;
+    var _a19, _b9, _c;
+    return (_c = (_b9 = (_a19 = this.config).buildRequestUrl) == null ? undefined : _b9.call(_a19, this.config.baseURL, isStreaming)) != null ? _c : `${this.config.baseURL}/messages`;
   }
   transformRequestBody(args) {
-    var _a18, _b8, _c;
-    return (_c = (_b8 = (_a18 = this.config).transformRequestBody) == null ? undefined : _b8.call(_a18, args)) != null ? _c : args;
+    var _a19, _b9, _c;
+    return (_c = (_b9 = (_a19 = this.config).transformRequestBody) == null ? undefined : _b9.call(_a19, args)) != null ? _c : args;
   }
   extractCitationDocuments(prompt) {
     const isCitationPart = (part) => {
-      var _a18, _b8;
+      var _a19, _b9;
       if (part.type !== "file") {
         return false;
       }
       if (part.mediaType !== "application/pdf" && part.mediaType !== "text/plain") {
         return false;
       }
-      const anthropic2 = (_a18 = part.providerOptions) == null ? undefined : _a18.anthropic;
+      const anthropic2 = (_a19 = part.providerOptions) == null ? undefined : _a19.anthropic;
       const citationsConfig = anthropic2 == null ? undefined : anthropic2.citations;
-      return (_b8 = citationsConfig == null ? undefined : citationsConfig.enabled) != null ? _b8 : false;
+      return (_b9 = citationsConfig == null ? undefined : citationsConfig.enabled) != null ? _b9 : false;
     };
     return prompt.filter((message) => message.role === "user").flatMap((message) => message.content).filter(isCitationPart).map((part) => {
-      var _a18;
+      var _a19;
       const filePart = part;
       return {
-        title: (_a18 = filePart.filename) != null ? _a18 : "Untitled Document",
+        title: (_a19 = filePart.filename) != null ? _a19 : "Untitled Document",
         filename: filePart.filename,
         mediaType: filePart.mediaType
       };
     });
   }
   async doGenerate(options) {
-    var _a18, _b8, _c, _d, _e, _f;
+    var _a19, _b9, _c, _d, _e, _f;
     const { args, warnings, betas, usesJsonResponseTool } = await this.getArgs(options);
     const citationDocuments = this.extractCitationDocuments(options.prompt);
     const {
@@ -49238,11 +50731,11 @@ var AnthropicMessagesLanguageModel = class {
               toolCallId: part.tool_use_id,
               toolName: "web_search",
               result: part.content.map((result) => {
-                var _a24;
+                var _a25;
                 return {
                   url: result.url,
                   title: result.title,
-                  pageAge: (_a24 = result.page_age) != null ? _a24 : null,
+                  pageAge: (_a25 = result.page_age) != null ? _a25 : null,
                   encryptedContent: result.encrypted_content,
                   type: result.type
                 };
@@ -49258,7 +50751,7 @@ var AnthropicMessagesLanguageModel = class {
                 title: result.title,
                 providerMetadata: {
                   anthropic: {
-                    pageAge: (_a18 = result.page_age) != null ? _a18 : null
+                    pageAge: (_a19 = result.page_age) != null ? _a19 : null
                   }
                 }
               });
@@ -49330,7 +50823,7 @@ var AnthropicMessagesLanguageModel = class {
         inputTokens: response.usage.input_tokens,
         outputTokens: response.usage.output_tokens,
         totalTokens: response.usage.input_tokens + response.usage.output_tokens,
-        cachedInputTokens: (_b8 = response.usage.cache_read_input_tokens) != null ? _b8 : undefined
+        cachedInputTokens: (_b9 = response.usage.cache_read_input_tokens) != null ? _b9 : undefined
       },
       request: { body: args },
       response: {
@@ -49380,7 +50873,7 @@ var AnthropicMessagesLanguageModel = class {
           controller.enqueue({ type: "stream-start", warnings });
         },
         transform(chunk, controller) {
-          var _a18, _b8, _c, _d, _e, _f, _g, _h;
+          var _a19, _b9, _c, _d, _e, _f, _g, _h;
           if (options.includeRawChunks) {
             controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
           }
@@ -49513,11 +51006,11 @@ var AnthropicMessagesLanguageModel = class {
                       toolCallId: part.tool_use_id,
                       toolName: "web_search",
                       result: part.content.map((result) => {
-                        var _a24;
+                        var _a25;
                         return {
                           url: result.url,
                           title: result.title,
-                          pageAge: (_a24 = result.page_age) != null ? _a24 : null,
+                          pageAge: (_a25 = result.page_age) != null ? _a25 : null,
                           encryptedContent: result.encrypted_content,
                           type: result.type
                         };
@@ -49533,7 +51026,7 @@ var AnthropicMessagesLanguageModel = class {
                         title: result.title,
                         providerMetadata: {
                           anthropic: {
-                            pageAge: (_a18 = result.page_age) != null ? _a18 : null
+                            pageAge: (_a19 = result.page_age) != null ? _a19 : null
                           }
                         }
                       });
@@ -49726,7 +51219,7 @@ var AnthropicMessagesLanguageModel = class {
             }
             case "message_start": {
               usage.inputTokens = value.message.usage.input_tokens;
-              usage.cachedInputTokens = (_b8 = value.message.usage.cache_read_input_tokens) != null ? _b8 : undefined;
+              usage.cachedInputTokens = (_b9 = value.message.usage.cache_read_input_tokens) != null ? _b9 : undefined;
               rawUsage = {
                 ...value.message.usage
               };
@@ -49949,8 +51442,8 @@ var anthropicTools = {
   webSearch_20250305
 };
 function createAnthropic(options = {}) {
-  var _a18;
-  const baseURL = (_a18 = withoutTrailingSlash(options.baseURL)) != null ? _a18 : "https://api.anthropic.com/v1";
+  var _a19;
+  const baseURL = (_a19 = withoutTrailingSlash(options.baseURL)) != null ? _a19 : "https://api.anthropic.com/v1";
   const getHeaders = () => withUserAgentSuffix({
     "anthropic-version": "2023-06-01",
     "x-api-key": loadApiKey({
@@ -49959,15 +51452,15 @@ function createAnthropic(options = {}) {
       description: "Anthropic"
     }),
     ...options.headers
-  }, `ai-sdk/anthropic/${VERSION4}`);
+  }, `ai-sdk/anthropic/${VERSION5}`);
   const createChatModel = (modelId) => {
-    var _a24;
+    var _a25;
     return new AnthropicMessagesLanguageModel(modelId, {
       provider: "anthropic.messages",
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a24 = options.generateId) != null ? _a24 : generateId,
+      generateId: (_a25 = options.generateId) != null ? _a25 : generateId,
       supportedUrls: () => ({
         "image/*": [/^https?:\/\/.*$/]
       })
@@ -50046,7 +51539,7 @@ function convertToOpenAIChatMessages({
         messages.push({
           role: "user",
           content: content.map((part, index) => {
-            var _a18, _b8, _c;
+            var _a19, _b9, _c;
             switch (part.type) {
               case "text": {
                 return { type: "text", text: part.text };
@@ -50058,7 +51551,7 @@ function convertToOpenAIChatMessages({
                     type: "image_url",
                     image_url: {
                       url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`,
-                      detail: (_b8 = (_a18 = part.providerOptions) == null ? undefined : _a18.openai) == null ? undefined : _b8.imageDetail
+                      detail: (_b9 = (_a19 = part.providerOptions) == null ? undefined : _a19.openai) == null ? undefined : _b9.imageDetail
                     }
                   };
                 } else if (part.mediaType.startsWith("audio/")) {
@@ -50338,21 +51831,21 @@ function prepareChatTools({
     return { tools: undefined, toolChoice: undefined, toolWarnings };
   }
   const openaiTools2 = [];
-  for (const tool2 of tools) {
-    switch (tool2.type) {
+  for (const tool3 of tools) {
+    switch (tool3.type) {
       case "function":
         openaiTools2.push({
           type: "function",
           function: {
-            name: tool2.name,
-            description: tool2.description,
-            parameters: tool2.inputSchema,
+            name: tool3.name,
+            description: tool3.description,
+            parameters: tool3.inputSchema,
             strict: structuredOutputs ? strictJsonSchema : undefined
           }
         });
         break;
       default:
-        toolWarnings.push({ type: "unsupported-tool", tool: tool2 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool3 });
         break;
     }
   }
@@ -50411,14 +51904,14 @@ var OpenAIChatLanguageModel = class {
     toolChoice,
     providerOptions
   }) {
-    var _a18, _b8, _c, _d;
+    var _a19, _b9, _c, _d;
     const warnings = [];
-    const openaiOptions = (_a18 = await parseProviderOptions({
+    const openaiOptions = (_a19 = await parseProviderOptions({
       provider: "openai",
       providerOptions,
       schema: openaiChatLanguageModelOptions
-    })) != null ? _a18 : {};
-    const structuredOutputs = (_b8 = openaiOptions.structuredOutputs) != null ? _b8 : true;
+    })) != null ? _a19 : {};
+    const structuredOutputs = (_b9 = openaiOptions.structuredOutputs) != null ? _b9 : true;
     if (topK != null) {
       warnings.push({
         type: "unsupported-setting",
@@ -50578,7 +52071,7 @@ var OpenAIChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a18, _b8, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a19, _b9, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
     const { args: body, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
@@ -50602,10 +52095,10 @@ var OpenAIChatLanguageModel = class {
     if (text2 != null && text2.length > 0) {
       content.push({ type: "text", text: text2 });
     }
-    for (const toolCall of (_a18 = choice.message.tool_calls) != null ? _a18 : []) {
+    for (const toolCall of (_a19 = choice.message.tool_calls) != null ? _a19 : []) {
       content.push({
         type: "tool-call",
-        toolCallId: (_b8 = toolCall.id) != null ? _b8 : generateId(),
+        toolCallId: (_b9 = toolCall.id) != null ? _b9 : generateId(),
         toolName: toolCall.function.name,
         input: toolCall.function.arguments
       });
@@ -50688,7 +52181,7 @@ var OpenAIChatLanguageModel = class {
           controller.enqueue({ type: "stream-start", warnings });
         },
         transform(chunk, controller) {
-          var _a18, _b8, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+          var _a19, _b9, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
           if (options.includeRawChunks) {
             controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
           }
@@ -50711,8 +52204,8 @@ var OpenAIChatLanguageModel = class {
             });
           }
           if (value.usage != null) {
-            usage.inputTokens = (_a18 = value.usage.prompt_tokens) != null ? _a18 : undefined;
-            usage.outputTokens = (_b8 = value.usage.completion_tokens) != null ? _b8 : undefined;
+            usage.inputTokens = (_a19 = value.usage.prompt_tokens) != null ? _a19 : undefined;
+            usage.outputTokens = (_b9 = value.usage.completion_tokens) != null ? _b9 : undefined;
             usage.totalTokens = (_c = value.usage.total_tokens) != null ? _c : undefined;
             usage.reasoningTokens = (_e = (_d = value.usage.completion_tokens_details) == null ? undefined : _d.reasoning_tokens) != null ? _e : undefined;
             usage.cachedInputTokens = (_g = (_f = value.usage.prompt_tokens_details) == null ? undefined : _f.cached_tokens) != null ? _g : undefined;
@@ -50872,11 +52365,11 @@ function supportsPriorityProcessing(modelId) {
   return modelId.startsWith("gpt-4") || modelId.startsWith("gpt-5-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-nano") && !modelId.startsWith("gpt-5-chat") || modelId.startsWith("o3") || modelId.startsWith("o4-mini");
 }
 function getSystemMessageMode(modelId) {
-  var _a18, _b8;
+  var _a19, _b9;
   if (!isReasoningModel(modelId)) {
     return "system";
   }
-  return (_b8 = (_a18 = reasoningModels[modelId]) == null ? undefined : _a18.systemMessageMode) != null ? _b8 : "developer";
+  return (_b9 = (_a19 = reasoningModels[modelId]) == null ? undefined : _a19.systemMessageMode) != null ? _b9 : "developer";
 }
 var reasoningModels = {
   "o1-mini": {
@@ -51137,7 +52630,7 @@ var OpenAICompletionLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a18, _b8, _c;
+    var _a19, _b9, _c;
     const { args, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
@@ -51163,8 +52656,8 @@ var OpenAICompletionLanguageModel = class {
     return {
       content: [{ type: "text", text: choice.text }],
       usage: {
-        inputTokens: (_a18 = response.usage) == null ? undefined : _a18.prompt_tokens,
-        outputTokens: (_b8 = response.usage) == null ? undefined : _b8.completion_tokens,
+        inputTokens: (_a19 = response.usage) == null ? undefined : _a19.prompt_tokens,
+        outputTokens: (_b9 = response.usage) == null ? undefined : _b9.completion_tokens,
         totalTokens: (_c = response.usage) == null ? undefined : _c.total_tokens
       },
       finishReason: mapOpenAIFinishReason2(choice.finish_reason),
@@ -51297,7 +52790,7 @@ var OpenAIEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a18;
+    var _a19;
     if (values.length > this.maxEmbeddingsPerCall) {
       throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
@@ -51306,11 +52799,11 @@ var OpenAIEmbeddingModel = class {
         values
       });
     }
-    const openaiOptions = (_a18 = await parseProviderOptions({
+    const openaiOptions = (_a19 = await parseProviderOptions({
       provider: "openai",
       providerOptions,
       schema: openaiEmbeddingProviderOptions
-    })) != null ? _a18 : {};
+    })) != null ? _a19 : {};
     const {
       responseHeaders,
       value: response,
@@ -51363,8 +52856,8 @@ var OpenAIImageModel = class {
     this.specificationVersion = "v2";
   }
   get maxImagesPerCall() {
-    var _a18;
-    return (_a18 = modelMaxImagesPerCall[this.modelId]) != null ? _a18 : 1;
+    var _a19;
+    return (_a19 = modelMaxImagesPerCall[this.modelId]) != null ? _a19 : 1;
   }
   get provider() {
     return this.config.provider;
@@ -51379,7 +52872,7 @@ var OpenAIImageModel = class {
     headers,
     abortSignal
   }) {
-    var _a18, _b8, _c, _d;
+    var _a19, _b9, _c, _d;
     const warnings = [];
     if (aspectRatio != null) {
       warnings.push({
@@ -51391,7 +52884,7 @@ var OpenAIImageModel = class {
     if (seed != null) {
       warnings.push({ type: "unsupported-setting", setting: "seed" });
     }
-    const currentDate = (_c = (_b8 = (_a18 = this.config._internal) == null ? undefined : _a18.currentDate) == null ? undefined : _b8.call(_a18)) != null ? _c : /* @__PURE__ */ new Date;
+    const currentDate = (_c = (_b9 = (_a19 = this.config._internal) == null ? undefined : _a19.currentDate) == null ? undefined : _b9.call(_a19)) != null ? _c : /* @__PURE__ */ new Date;
     const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/images/generations",
@@ -51623,7 +53116,7 @@ async function convertToOpenAIResponsesInput({
   store,
   hasLocalShellTool = false
 }) {
-  var _a18, _b8, _c, _d;
+  var _a19, _b9, _c, _d;
   const input = [];
   const warnings = [];
   for (const { role, content } of prompt) {
@@ -51656,7 +53149,7 @@ async function convertToOpenAIResponsesInput({
         input.push({
           role: "user",
           content: content.map((part, index) => {
-            var _a24, _b22, _c2;
+            var _a25, _b23, _c2;
             switch (part.type) {
               case "text": {
                 return { type: "input_text", text: part.text };
@@ -51669,7 +53162,7 @@ async function convertToOpenAIResponsesInput({
                     ...part.data instanceof URL ? { image_url: part.data.toString() } : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
                       image_url: `data:${mediaType};base64,${convertToBase64(part.data)}`
                     },
-                    detail: (_b22 = (_a24 = part.providerOptions) == null ? undefined : _a24.openai) == null ? undefined : _b22.imageDetail
+                    detail: (_b23 = (_a25 = part.providerOptions) == null ? undefined : _a25.openai) == null ? undefined : _b23.imageDetail
                   };
                 } else if (part.mediaType === "application/pdf") {
                   if (part.data instanceof URL) {
@@ -51702,7 +53195,7 @@ async function convertToOpenAIResponsesInput({
         for (const part of content) {
           switch (part.type) {
             case "text": {
-              const id = (_b8 = (_a18 = part.providerOptions) == null ? undefined : _a18.openai) == null ? undefined : _b8.itemId;
+              const id = (_b9 = (_a19 = part.providerOptions) == null ? undefined : _a19.openai) == null ? undefined : _b9.itemId;
               if (store && id != null) {
                 input.push({ type: "item_reference", id });
                 break;
@@ -52378,22 +53871,22 @@ async function prepareResponsesTools({
     return { tools: undefined, toolChoice: undefined, toolWarnings };
   }
   const openaiTools2 = [];
-  for (const tool2 of tools) {
-    switch (tool2.type) {
+  for (const tool3 of tools) {
+    switch (tool3.type) {
       case "function":
         openaiTools2.push({
           type: "function",
-          name: tool2.name,
-          description: tool2.description,
-          parameters: tool2.inputSchema,
+          name: tool3.name,
+          description: tool3.description,
+          parameters: tool3.inputSchema,
           strict: strictJsonSchema
         });
         break;
       case "provider-defined": {
-        switch (tool2.id) {
+        switch (tool3.id) {
           case "openai.file_search": {
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: fileSearchArgsSchema
             });
             openaiTools2.push({
@@ -52416,7 +53909,7 @@ async function prepareResponsesTools({
           }
           case "openai.web_search_preview": {
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: webSearchPreviewArgsSchema
             });
             openaiTools2.push({
@@ -52428,7 +53921,7 @@ async function prepareResponsesTools({
           }
           case "openai.web_search": {
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: webSearchArgsSchema
             });
             openaiTools2.push({
@@ -52441,7 +53934,7 @@ async function prepareResponsesTools({
           }
           case "openai.code_interpreter": {
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: codeInterpreterArgsSchema
             });
             openaiTools2.push({
@@ -52452,7 +53945,7 @@ async function prepareResponsesTools({
           }
           case "openai.image_generation": {
             const args = await validateTypes({
-              value: tool2.args,
+              value: tool3.args,
               schema: imageGenerationArgsSchema
             });
             openaiTools2.push({
@@ -52476,7 +53969,7 @@ async function prepareResponsesTools({
         break;
       }
       default:
-        toolWarnings.push({ type: "unsupported-tool", tool: tool2 });
+        toolWarnings.push({ type: "unsupported-tool", tool: tool3 });
         break;
     }
   }
@@ -52531,7 +54024,7 @@ var OpenAIResponsesLanguageModel = class {
     toolChoice,
     responseFormat
   }) {
-    var _a18, _b8, _c, _d;
+    var _a19, _b9, _c, _d;
     const warnings = [];
     const modelConfig = getResponsesModelConfig(this.modelId);
     if (topK != null) {
@@ -52564,11 +54057,11 @@ var OpenAIResponsesLanguageModel = class {
       prompt,
       systemMessageMode: modelConfig.systemMessageMode,
       fileIdPrefixes: this.config.fileIdPrefixes,
-      store: (_a18 = openaiOptions == null ? undefined : openaiOptions.store) != null ? _a18 : true,
+      store: (_a19 = openaiOptions == null ? undefined : openaiOptions.store) != null ? _a19 : true,
       hasLocalShellTool: hasOpenAITool("openai.local_shell")
     });
     warnings.push(...inputWarnings);
-    const strictJsonSchema = (_b8 = openaiOptions == null ? undefined : openaiOptions.strictJsonSchema) != null ? _b8 : false;
+    const strictJsonSchema = (_b9 = openaiOptions == null ? undefined : openaiOptions.strictJsonSchema) != null ? _b9 : false;
     let include = openaiOptions == null ? undefined : openaiOptions.include;
     function addInclude(key) {
       if (include == null) {
@@ -52578,13 +54071,13 @@ var OpenAIResponsesLanguageModel = class {
       }
     }
     function hasOpenAITool(id) {
-      return (tools == null ? undefined : tools.find((tool2) => tool2.type === "provider-defined" && tool2.id === id)) != null;
+      return (tools == null ? undefined : tools.find((tool3) => tool3.type === "provider-defined" && tool3.id === id)) != null;
     }
     const topLogprobs = typeof (openaiOptions == null ? undefined : openaiOptions.logprobs) === "number" ? openaiOptions == null ? undefined : openaiOptions.logprobs : (openaiOptions == null ? undefined : openaiOptions.logprobs) === true ? TOP_LOGPROBS_MAX : undefined;
     if (topLogprobs) {
       addInclude("message.output_text.logprobs");
     }
-    const webSearchToolName = (_c = tools == null ? undefined : tools.find((tool2) => tool2.type === "provider-defined" && (tool2.id === "openai.web_search" || tool2.id === "openai.web_search_preview"))) == null ? undefined : _c.name;
+    const webSearchToolName = (_c = tools == null ? undefined : tools.find((tool3) => tool3.type === "provider-defined" && (tool3.id === "openai.web_search" || tool3.id === "openai.web_search_preview"))) == null ? undefined : _c.name;
     if (webSearchToolName) {
       addInclude("web_search_call.action.sources");
     }
@@ -52713,7 +54206,7 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a18, _b8, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+    var _a19, _b9, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
     const {
       args: body,
       warnings,
@@ -52763,7 +54256,7 @@ var OpenAIResponsesLanguageModel = class {
               providerMetadata: {
                 openai: {
                   itemId: part.id,
-                  reasoningEncryptedContent: (_a18 = part.encrypted_content) != null ? _a18 : null
+                  reasoningEncryptedContent: (_a19 = part.encrypted_content) != null ? _a19 : null
                 }
               }
             });
@@ -52807,7 +54300,7 @@ var OpenAIResponsesLanguageModel = class {
         }
         case "message": {
           for (const contentPart of part.content) {
-            if (((_c = (_b8 = options.providerOptions) == null ? undefined : _b8.openai) == null ? undefined : _c.logprobs) && contentPart.logprobs) {
+            if (((_c = (_b9 = options.providerOptions) == null ? undefined : _b9.openai) == null ? undefined : _c.logprobs) && contentPart.logprobs) {
               logprobs.push(contentPart.logprobs);
             }
             content.push({
@@ -53019,7 +54512,7 @@ var OpenAIResponsesLanguageModel = class {
           controller.enqueue({ type: "stream-start", warnings });
         },
         transform(chunk, controller) {
-          var _a18, _b8, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
+          var _a19, _b9, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
           if (options.includeRawChunks) {
             controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
           }
@@ -53129,7 +54622,7 @@ var OpenAIResponsesLanguageModel = class {
                 providerMetadata: {
                   openai: {
                     itemId: value.item.id,
-                    reasoningEncryptedContent: (_a18 = value.item.encrypted_content) != null ? _a18 : null
+                    reasoningEncryptedContent: (_a19 = value.item.encrypted_content) != null ? _a19 : null
                   }
                 }
               });
@@ -53193,7 +54686,7 @@ var OpenAIResponsesLanguageModel = class {
                 toolName: "file_search",
                 result: {
                   queries: value.item.queries,
-                  results: (_c = (_b8 = value.item.results) == null ? undefined : _b8.map((result) => ({
+                  results: (_c = (_b9 = value.item.results) == null ? undefined : _b9.map((result) => ({
                     attributes: result.attributes,
                     fileId: result.file_id,
                     filename: result.filename,
@@ -53499,10 +54992,10 @@ function getResponsesModelConfig(modelId) {
   };
 }
 function mapWebSearchOutput(action) {
-  var _a18;
+  var _a19;
   switch (action.type) {
     case "search":
-      return { action: { type: "search", query: (_a18 = action.query) != null ? _a18 : undefined } };
+      return { action: { type: "search", query: (_a19 = action.query) != null ? _a19 : undefined } };
     case "open_page":
       return { action: { type: "openPage", url: action.url } };
     case "find":
@@ -53580,8 +55073,8 @@ var OpenAISpeechModel = class {
     };
   }
   async doGenerate(options) {
-    var _a18, _b8, _c;
-    const currentDate = (_c = (_b8 = (_a18 = this.config._internal) == null ? undefined : _a18.currentDate) == null ? undefined : _b8.call(_a18)) != null ? _c : /* @__PURE__ */ new Date;
+    var _a19, _b9, _c;
+    const currentDate = (_c = (_b9 = (_a19 = this.config._internal) == null ? undefined : _a19.currentDate) == null ? undefined : _b9.call(_a19)) != null ? _c : /* @__PURE__ */ new Date;
     const { requestBody, warnings } = await this.getArgs(options);
     const {
       value: audio,
@@ -53757,8 +55250,8 @@ var OpenAITranscriptionModel = class {
     };
   }
   async doGenerate(options) {
-    var _a18, _b8, _c, _d, _e, _f, _g, _h;
-    const currentDate = (_c = (_b8 = (_a18 = this.config._internal) == null ? undefined : _a18.currentDate) == null ? undefined : _b8.call(_a18)) != null ? _c : /* @__PURE__ */ new Date;
+    var _a19, _b9, _c, _d, _e, _f, _g, _h;
+    const currentDate = (_c = (_b9 = (_a19 = this.config._internal) == null ? undefined : _a19.currentDate) == null ? undefined : _b9.call(_a19)) != null ? _c : /* @__PURE__ */ new Date;
     const { formData, warnings } = await this.getArgs(options);
     const {
       value: response,
@@ -53800,14 +55293,14 @@ var OpenAITranscriptionModel = class {
     };
   }
 };
-var VERSION5 = "2.0.52";
+var VERSION6 = "2.0.52";
 function createOpenAI(options = {}) {
-  var _a18, _b8;
-  const baseURL = (_a18 = withoutTrailingSlash(loadOptionalSetting({
+  var _a19, _b9;
+  const baseURL = (_a19 = withoutTrailingSlash(loadOptionalSetting({
     settingValue: options.baseURL,
     environmentVariableName: "OPENAI_BASE_URL"
-  }))) != null ? _a18 : "https://api.openai.com/v1";
-  const providerName = (_b8 = options.name) != null ? _b8 : "openai";
+  }))) != null ? _a19 : "https://api.openai.com/v1";
+  const providerName = (_b9 = options.name) != null ? _b9 : "openai";
   const getHeaders = () => withUserAgentSuffix({
     Authorization: `Bearer ${loadApiKey({
       apiKey: options.apiKey,
@@ -53817,7 +55310,7 @@ function createOpenAI(options = {}) {
     "OpenAI-Organization": options.organization,
     "OpenAI-Project": options.project,
     ...options.headers
-  }, `ai-sdk/openai/${VERSION5}`);
+  }, `ai-sdk/openai/${VERSION6}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
     url: ({ path }) => `${baseURL}${path}`,
@@ -57499,29 +58992,29 @@ var ma = function() {
   var e3, t2, n2, r2, a2, o2, c2, l2;
 }();
 var ya;
-var _a18;
+var _a19;
 var ga;
 async function ka(e3, a2, i2, s2, o2) {
   try {
     if (!ya) {
-      const n2 = new ma(new URL(e3 || "http://localhost:3000/mcp"));
-      ya = await createMCPClient({ transport: n2 });
+      const t2 = new ma(new URL(e3 || "http://localhost:3000/mcp"));
+      ya = await createMCPClient({ transport: t2 });
     }
-    if (!_a18)
+    if (!_a19)
       switch (a2) {
         case "openai":
           const e4 = createOpenAI({ apiKey: s2 });
-          _a18 = e4(i2);
+          _a19 = e4(i2);
           break;
         case "anthropic":
           const t2 = createAnthropic({ apiKey: s2 });
-          _a18 = t2(i2);
+          _a19 = t2(i2);
           break;
         default:
           throw new Error("Invalid AI provider");
       }
     ga || (ga = await ya.tools());
-    return (await streamText({ model: _a18, tools: ga, stopWhen: stepCountIs(5), messages: [{ role: "user", content: [{ type: "text", text: o2 }] }] })).textStream;
+    return (await streamText({ model: _a19, tools: ga, stopWhen: stepCountIs(5), messages: [{ role: "user", content: [{ type: "text", text: o2 }] }] })).textStream;
   } catch (e4) {
     throw console.error(e4), e4;
   }