@ai-sdk/quiverai 2.0.47 → 2.0.50

package/dist/index.js

@@ -2,6 +2,9 @@
 import {
   NoSuchModelError
 } from "@ai-sdk/provider";
+import {
+  createOpenResponses as createOpenResponses2
+} from "@ai-sdk/open-responses";
 import {
   loadApiKey,
   loadOptionalSetting,
@@ -9,33 +12,168 @@ import {
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
 
+// src/quiverai-error.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var quiveraiErrorSchema = z.object({
+  status: z.number().int(),
+  code: z.string().min(1),
+  message: z.string().min(1),
+  request_id: z.string().min(1)
+});
+var quiveraiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: quiveraiErrorSchema,
+  errorToMessage: (error) => error.message,
+  isRetryable: (response) => response.status === 429 || response.status >= 500
+});
+var getQuiverAIResponseErrorMetadata = (error) => ({
+  statusCode: typeof error.status_code === "number" && Number.isInteger(error.status_code) && error.status_code >= 400 && error.status_code <= 599 ? error.status_code : void 0
+});
+
+// src/quiverai-language-model.ts
+import {
+  InvalidArgumentError
+} from "@ai-sdk/provider";
+import {
+  createOpenResponses
+} from "@ai-sdk/open-responses";
+import {
+  serializeModelOptions,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE
+} from "@ai-sdk/provider-utils";
+var QuiverAILanguageModel = class _QuiverAILanguageModel {
+  constructor(model, config) {
+    this.model = model;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    const config = {
+      ...options.config,
+      failedResponseHandler: quiveraiFailedResponseHandler,
+      getResponseErrorMetadata: getQuiverAIResponseErrorMetadata
+    };
+    return new _QuiverAILanguageModel(
+      createOpenResponses(config).languageModel(options.modelId),
+      config
+    );
+  }
+  get modelId() {
+    return this.model.modelId;
+  }
+  get provider() {
+    return this.model.provider;
+  }
+  get supportedUrls() {
+    return this.model.supportedUrls;
+  }
+  async doGenerate(options) {
+    const prepared = prepareQuiverAICall(options);
+    const result = await this.model.doGenerate(prepared.options);
+    return { ...result, warnings: [...prepared.warnings, ...result.warnings] };
+  }
+  async doStream(options) {
+    const prepared = prepareQuiverAICall(options);
+    const result = await this.model.doStream(prepared.options);
+    if (prepared.warnings.length === 0) return result;
+    return {
+      ...result,
+      stream: result.stream.pipeThrough(
+        new TransformStream({
+          transform(part, controller) {
+            controller.enqueue(
+              part.type === "stream-start" ? {
+                ...part,
+                warnings: [...prepared.warnings, ...part.warnings]
+              } : part
+            );
+          }
+        })
+      )
+    };
+  }
+};
+function prepareQuiverAICall(options) {
+  const { reasoningEffort, reasoningSummary } = options.providerOptions?.quiverai ?? {};
+  if (reasoningEffort != null && (typeof reasoningEffort !== "string" || !["low", "medium", "high", "xhigh"].includes(reasoningEffort))) {
+    throw new InvalidArgumentError({
+      argument: "providerOptions",
+      message: `Unsupported reasoning effort: ${reasoningEffort}`
+    });
+  }
+  if (reasoningSummary != null && reasoningSummary !== "auto") {
+    throw new InvalidArgumentError({
+      argument: "providerOptions",
+      message: `Unsupported reasoning summary: ${reasoningSummary}`
+    });
+  }
+  const warnings = [];
+  const omitReasoning = options.reasoning === "none" && reasoningEffort == null;
+  if (omitReasoning) {
+    warnings.push({ type: "unsupported", feature: "reasoning effort none" });
+  }
+  return {
+    warnings,
+    options: {
+      ...options,
+      reasoning: omitReasoning ? void 0 : options.reasoning,
+      prompt: options.prompt.map(
+        (message) => message.role !== "assistant" ? message : {
+          ...message,
+          content: message.content.map((part) => {
+            if (part.type !== "reasoning") return part;
+            const metadata = part.providerOptions?.quiverai ?? part.providerMetadata?.quiverai;
+            return {
+              ...part,
+              text: "",
+              providerOptions: {
+                ...part.providerOptions,
+                quiverai: {
+                  itemId: metadata?.itemId,
+                  reasoningSummary: metadata?.reasoningSummary
+                }
+              }
+            };
+          })
+        }
+      )
+    }
+  };
+}
+
 // src/quiverai-image-model.ts
 import {
-  InvalidArgumentError as InvalidArgumentError2
+  InvalidArgumentError as InvalidArgumentError3
 } from "@ai-sdk/provider";
 import {
   combineHeaders,
   convertBase64ToUint8Array as convertBase64ToUint8Array2,
   convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
-  createJsonErrorResponseHandler,
   createJsonResponseHandler,
   parseProviderOptions,
   postJsonToApi,
-  serializeModelOptions,
-  WORKFLOW_DESERIALIZE,
-  WORKFLOW_SERIALIZE
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2
 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
+import { z as z3 } from "zod/v4";
 
 // src/quiverai-image-model-options.ts
 import {
   lazySchema,
   zodSchema
 } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
+import { z as z2 } from "zod/v4";
 var quiveraiImageModelOptionsSchema = lazySchema(
   () => zodSchema(
-    z.object({
+    z2.object({
       /**
        * The operation to perform. Defaults to `generate`.
        *
@@ -47,81 +185,81 @@ var quiveraiImageModelOptionsSchema = lazySchema(
        * - `edit`: Edit a single SVG from `prompt.images` using `prompt.text`
        *   as the required instruction.
        */
-      operation: z.enum(["generate", "vectorize", "animate", "edit"]).optional(),
+      operation: z2.enum(["generate", "vectorize", "animate", "edit"]).optional(),
       /**
        * Extra style guidance for prompt-based generation.
        */
-      instructions: z.string().min(1).optional(),
+      instructions: z2.string().min(1).optional(),
       /**
        * Reasoning effort applied to generation or vectorization.
        */
-      reasoningEffort: z.enum(["low", "medium", "high", "xhigh"]).optional(),
+      reasoningEffort: z2.enum(["low", "medium", "high", "xhigh"]).optional(),
       /**
        * Optional reference images for SVG editing. Use
        * `prepareQuiverAIImageReference` to convert binary inputs.
        */
-      referenceImages: z.array(
-        z.union([
-          z.object({ url: z.string().min(1) }).strict(),
-          z.object({ base64: z.string().min(1).max(16777216) }).strict()
+      referenceImages: z2.array(
+        z2.union([
+          z2.object({ url: z2.string().min(1) }).strict(),
+          z2.object({ base64: z2.string().min(1).max(16777216) }).strict()
         ])
       ).max(4).optional(),
       /**
        * Maximum number of edit review and redo steps (0-5).
        */
-      maxReviewSteps: z.number().int().min(0).max(5).optional(),
+      maxReviewSteps: z2.number().int().min(0).max(5).optional(),
       /**
        * SVG root attributes requested for generation or vectorization.
        */
-      attributes: z.object({
-        viewBox: z.object({
-          minX: z.number(),
-          minY: z.number(),
-          width: z.number().positive(),
-          height: z.number().positive()
+      attributes: z2.object({
+        viewBox: z2.object({
+          minX: z2.number(),
+          minY: z2.number(),
+          width: z2.number().positive(),
+          height: z2.number().positive()
         }).optional()
       }).optional(),
       /**
        * Sampling temperature (0-2).
        */
-      temperature: z.number().min(0).max(2).optional(),
+      temperature: z2.number().min(0).max(2).optional(),
       /**
        * Nucleus sampling top-p (0-1).
        */
-      topP: z.number().min(0).max(1).optional(),
+      topP: z2.number().min(0).max(1).optional(),
       /**
        * Presence penalty (-2 to 2).
        */
-      presencePenalty: z.number().min(-2).max(2).nullable().optional(),
+      presencePenalty: z2.number().min(-2).max(2).nullable().optional(),
       /**
        * Maximum number of output tokens (1 - 65536 for Arrow 2 models).
        * The legacy upper bound of 131072 is retained for other model IDs.
        */
-      maxOutputTokens: z.number().int().min(1).max(131072).optional(),
+      maxOutputTokens: z2.number().int().min(1).max(131072).optional(),
       /**
        * Provider orchestrator token budget for SVG editing (1-65536).
        */
-      orchestratorMaxOutputTokens: z.number().int().min(1).max(65536).optional(),
+      orchestratorMaxOutputTokens: z2.number().int().min(1).max(65536).optional(),
       /**
        * Provider shallow edit token budget for SVG editing (1-65536).
        */
-      shallowMaxOutputTokens: z.number().int().min(1).max(65536).optional(),
+      shallowMaxOutputTokens: z2.number().int().min(1).max(65536).optional(),
       /**
        * Whether to auto-crop the input image before vectorization.
        * Only used when `operation` is `vectorize`.
        */
-      autoCrop: z.boolean().optional(),
+      autoCrop: z2.boolean().optional(),
       /**
        * Target canvas size in pixels for vectorization (128 - 4096).
        * Only used when `operation` is `vectorize`.
        */
-      targetSize: z.number().int().min(128).max(4096).optional()
+      targetSize: z2.number().int().min(128).max(4096).optional()
     })
   )
 );
 
 // src/prepare-quiverai-image-reference.ts
-import { InvalidArgumentError } from "@ai-sdk/provider";
+import { InvalidArgumentError as InvalidArgumentError2 } from "@ai-sdk/provider";
 import {
   convertBase64ToUint8Array,
   convertUint8ArrayToBase64,
@@ -147,7 +285,7 @@ function prepareQuiverAIImageReference(input) {
     if (input.startsWith("data:")) {
       const match = /^data:([^;,]+);base64,(.+)$/s.exec(input);
       if (match == null || !supportedReferenceMediaTypes.has(match[1])) {
-        throw new InvalidArgumentError({
+        throw new InvalidArgumentError2({
           argument: "input",
           message: "QuiverAI reference image data URLs must use base64 encoding and a supported image media type."
         });
@@ -166,14 +304,14 @@ function validateQuiverAIImageUrl(url) {
   let parsed;
   try {
     parsed = new URL(url);
-  } catch (e) {
-    throw new InvalidArgumentError({
+  } catch {
+    throw new InvalidArgumentError2({
       argument: "url",
       message: "QuiverAI image URLs must be valid HTTP or HTTPS URLs."
     });
   }
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "url",
       message: "QuiverAI image URLs must use HTTP or HTTPS."
     });
@@ -182,7 +320,7 @@ function validateQuiverAIImageUrl(url) {
 }
 function validateQuiverAIReferenceBase64(base64, argument) {
   if (base64.length === 0 || base64.length > MAX_REFERENCE_BASE64_LENGTH) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument,
       message: `QuiverAI reference images must contain 1-${MAX_REFERENCE_BASE64_LENGTH} base64 characters.`
     });
@@ -191,7 +329,7 @@ function validateQuiverAIReferenceBase64(base64, argument) {
   try {
     data = convertBase64ToUint8Array(base64);
   } catch (cause) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument,
       message: "QuiverAI reference image data must be valid base64.",
       cause
@@ -201,14 +339,14 @@ function validateQuiverAIReferenceBase64(base64, argument) {
 }
 function validateQuiverAIReferenceBytes(data, argument) {
   if (data.length === 0 || data.length > MAX_REFERENCE_BYTES) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument,
       message: `QuiverAI reference images must decode to 1-${MAX_REFERENCE_BYTES} bytes.`
     });
   }
   const mediaType = isSvg(data) ? "image/svg+xml" : detectMediaType({ data, topLevelType: "image" });
   if (mediaType == null || !supportedReferenceMediaTypes.has(mediaType)) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument,
       message: "QuiverAI reference images must be PNG, JPEG, WebP, GIF, or SVG data."
     });
@@ -218,7 +356,7 @@ function isSvg(data) {
   let text;
   try {
     text = new TextDecoder("utf-8", { fatal: true }).decode(data);
-  } catch (e) {
+  } catch {
     return false;
   }
   const normalized = text.replace(/^\uFEFF/, "").trim();
@@ -238,13 +376,13 @@ var QuiverAIImageModel = class _QuiverAIImageModel {
   get provider() {
     return this.config.provider;
   }
-  static [WORKFLOW_SERIALIZE](model) {
-    return serializeModelOptions({
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
       modelId: model.modelId,
       config: model.config
     });
   }
-  static [WORKFLOW_DESERIALIZE](options) {
+  static [WORKFLOW_DESERIALIZE2](options) {
     return new _QuiverAIImageModel(options.modelId, options.config);
   }
   async doGenerate({
@@ -259,13 +397,12 @@ var QuiverAIImageModel = class _QuiverAIImageModel {
     headers,
     abortSignal
   }) {
-    var _a, _b, _c, _d, _e, _f;
     const quiveraiOptions = await parseProviderOptions({
       provider: "quiverai",
       providerOptions,
       schema: quiveraiImageModelOptionsSchema
     });
-    const operation = (_a = quiveraiOptions == null ? void 0 : quiveraiOptions.operation) != null ? _a : "generate";
+    const operation = quiveraiOptions?.operation ?? "generate";
     const warnings = collectWarnings({ size, aspectRatio, seed, mask });
     const body = buildRequestBody({
       modelId: this.modelId,
@@ -274,10 +411,10 @@ var QuiverAIImageModel = class _QuiverAIImageModel {
       files,
       mask,
       operation,
-      options: quiveraiOptions != null ? quiveraiOptions : {}
+      options: quiveraiOptions ?? {}
     });
-    const currentDate = (_d = (_c = (_b = this.config._internal) == null ? void 0 : _b.currentDate) == null ? void 0 : _c.call(_b)) != null ? _d : /* @__PURE__ */ new Date();
-    const combinedHeaders = combineHeaders((_f = (_e = this.config).headers) == null ? void 0 : _f.call(_e), headers);
+    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+    const combinedHeaders = combineHeaders(this.config.headers?.(), headers);
     const { value: response, responseHeaders } = await postJsonToApi({
       url: `${this.config.baseURL}${getOperationPath(operation)}`,
       headers: combinedHeaders,
@@ -349,19 +486,18 @@ function toQuiverAIImageReference(image) {
 }
 var maxAnimationSourceBase64Length = 1066668;
 function toQuiverAIAnimationSource(image) {
-  var _a;
   if (image.type === "url") {
     let url;
     try {
       url = new URL(image.url);
-    } catch (e) {
-      throw new InvalidArgumentError2({
+    } catch {
+      throw new InvalidArgumentError3({
         argument: "files",
         message: "QuiverAI animate requires a valid HTTP or HTTPS SVG URL."
       });
     }
     if (url.protocol !== "http:" && url.protocol !== "https:") {
-      throw new InvalidArgumentError2({
+      throw new InvalidArgumentError3({
         argument: "files",
         message: "QuiverAI animate requires an HTTP or HTTPS SVG URL."
       });
@@ -372,11 +508,11 @@ function toQuiverAIAnimationSource(image) {
   let bytes;
   if (typeof image.data === "string") {
     const dataUrlMatch = /^data:image\/svg\+xml(?:;[^,]*)?;base64,([\s\S]+)$/i.exec(image.data);
-    const encodedData = (_a = dataUrlMatch == null ? void 0 : dataUrlMatch[1]) != null ? _a : image.data;
+    const encodedData = dataUrlMatch?.[1] ?? image.data;
     try {
       bytes = convertBase64ToUint8Array2(encodedData);
-    } catch (e) {
-      throw new InvalidArgumentError2({
+    } catch {
+      throw new InvalidArgumentError3({
         argument: "files",
         message: "QuiverAI animate requires the source SVG string to be valid base64 or an SVG data URL."
       });
@@ -387,13 +523,13 @@ function toQuiverAIAnimationSource(image) {
     base64 = convertUint8ArrayToBase642(bytes);
   }
   if (!isSvg2(bytes)) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI animate requires the input file to contain SVG data."
     });
   }
   if (base64.length > maxAnimationSourceBase64Length) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: `QuiverAI animate accepts at most ${maxAnimationSourceBase64Length} base64 characters for the source SVG.`
     });
@@ -416,7 +552,7 @@ function buildRequestBody({
   options
 }) {
   if ((modelId === "arrow-2" || modelId === "arrow-2-telos") && options.maxOutputTokens != null && options.maxOutputTokens > 65536) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "maxOutputTokens",
       message: `QuiverAI model "${modelId}" supports at most 65536 output tokens.`
     });
@@ -435,15 +571,15 @@ function buildRequestBody({
   }
   if (operation === "generate") {
     if (prompt == null || prompt.trim().length === 0) {
-      throw new InvalidArgumentError2({
+      throw new InvalidArgumentError3({
         argument: "prompt",
         message: "QuiverAI image generation requires a non-empty prompt for generateImage."
       });
     }
-    const references = files == null ? void 0 : files.map(toQuiverAIImageReference);
+    const references = files?.map(toQuiverAIImageReference);
     const maxReferences = getGenerateReferenceLimit(modelId);
     if (references != null && references.length > maxReferences) {
-      throw new InvalidArgumentError2({
+      throw new InvalidArgumentError3({
         argument: "files",
         message: `QuiverAI generate supports up to ${maxReferences} reference images for model "${modelId}".`
       });
@@ -478,19 +614,19 @@ function buildRequestBody({
     });
   }
   if (files == null || files.length === 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: 'QuiverAI vectorize requires an input image. Pass an image in the generateImage prompt and set providerOptions.quiverai.operation to "vectorize".'
     });
   }
   if (files.length > 1) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI vectorize accepts a single input image."
     });
   }
   if (n !== 1) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "n",
       message: "QuiverAI vectorize returns one SVG per request. Set maxImagesPerCall to 1 in generateImage to vectorize multiple times."
     });
@@ -512,37 +648,37 @@ function buildAnimationRequestBody({
   options
 }) {
   if (modelId !== "arrow-2" && modelId !== "arrow-2-telos") {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "modelId",
       message: 'QuiverAI animate is supported by the "arrow-2" and "arrow-2-telos" models.'
     });
   }
   if (files == null || files.length === 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI animate requires exactly one source SVG in prompt.images."
     });
   }
   if (files.length !== 1) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI animate accepts exactly one source SVG in prompt.images."
     });
   }
   if (n !== 1) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "n",
       message: "QuiverAI animate returns one SVG per request. Set maxImagesPerCall to 1 in generateImage to animate multiple times."
     });
   }
   if (mask != null) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "mask",
       message: "QuiverAI animate does not support masks."
     });
   }
   if (prompt != null && prompt.trim().length === 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "prompt",
       message: "QuiverAI animate requires a non-empty prompt when an animation instruction is provided."
     });
@@ -558,7 +694,7 @@ function buildAnimationRequestBody({
     return option[1] !== void 0;
   });
   if (unsupportedOptions.length > 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: `providerOptions.quiverai.${unsupportedOptions[0][0]}`,
       message: `QuiverAI animate does not support providerOptions.quiverai.${unsupportedOptions[0][0]}.`
     });
@@ -583,45 +719,44 @@ function buildEditRequestBody({
   mask,
   options
 }) {
-  var _a;
   if (!editModelIds.has(modelId)) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "modelId",
       message: 'QuiverAI SVG editing is supported by the "arrow-2" and "arrow-2-telos" models.'
     });
   }
   if (prompt == null || prompt.trim().length === 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "prompt",
       message: "QuiverAI SVG editing requires a non-empty instruction in generateImage prompt.text."
     });
   }
   if (prompt.length > 4e3) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "prompt",
       message: "QuiverAI SVG editing instructions must contain at most 4000 characters."
     });
   }
   if (files == null || files.length === 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI SVG editing requires one source SVG in generateImage prompt.images."
     });
   }
   if (files.length !== 1) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI SVG editing accepts exactly one source SVG."
     });
   }
   if (n !== 1) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "n",
       message: "QuiverAI SVG editing returns exactly one SVG per request. Set maxImagesPerCall to 1 in generateImage to edit multiple times."
     });
   }
   if (mask != null) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "mask",
       message: "QuiverAI SVG editing does not support masks."
     });
@@ -635,14 +770,14 @@ function buildEditRequestBody({
     ["targetSize", options.targetSize]
   ].flatMap(([name, value]) => value == null ? [] : [name]);
   if (unsupportedOptions.length > 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "providerOptions",
       message: `QuiverAI SVG editing does not support these provider options: ${unsupportedOptions.join(
         ", "
       )}.`
     });
   }
-  const referenceImages = (_a = options.referenceImages) == null ? void 0 : _a.map((reference, index) => {
+  const referenceImages = options.referenceImages?.map((reference, index) => {
     if ("url" in reference) {
       return {
         url: validateQuiverAIImageUrl(reference.url)
@@ -680,7 +815,7 @@ function rejectEditOnlyOptions(operation, options) {
     ["shallowMaxOutputTokens", options.shallowMaxOutputTokens]
   ].flatMap(([name, value]) => value == null ? [] : [name]);
   if (editOnlyOptions.length > 0) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "providerOptions",
       message: `QuiverAI ${operation} does not support these edit-only provider options: ${editOnlyOptions.join(
         ", "
@@ -700,14 +835,14 @@ function toQuiverAIEditSource(file) {
   try {
     data = typeof file.data === "string" ? convertBase64ToUint8Array2(file.data) : file.data;
   } catch (cause) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI SVG source data must be valid base64 or binary data.",
       cause
     });
   }
   if (data.length === 0 || data.length > MAX_EDIT_SVG_BYTES) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: `QuiverAI SVG source data must contain 1-${MAX_EDIT_SVG_BYTES} bytes.`
     });
@@ -716,14 +851,14 @@ function toQuiverAIEditSource(file) {
   try {
     svg = new TextDecoder("utf-8", { fatal: true }).decode(data);
   } catch (cause) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI SVG source data must be valid UTF-8.",
       cause
     });
   }
   if (svg.length > MAX_EDIT_SVG_BYTES || !isSvgMarkup(svg)) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "files",
       message: "QuiverAI SVG source data must contain a complete SVG document."
     });
@@ -735,7 +870,6 @@ function toQuiverAIEditSource(file) {
   };
 }
 function isSvgMarkup(svg) {
-  var _a;
   const document = svg.replace(/^\uFEFF/, "");
   const elements = [];
   let position = 0;
@@ -781,14 +915,14 @@ function isSvgMarkup(svg) {
       continue;
     }
     if (document.slice(position, position + 9).toUpperCase() === "<!DOCTYPE") {
-      if (rootSeen || doctypeSeen || elements.length > 0 || !/[\t\n\r ]/.test((_a = document[position + 9]) != null ? _a : "")) {
+      if (rootSeen || doctypeSeen || elements.length > 0 || !/[\t\n\r ]/.test(document[position + 9] ?? "")) {
         return false;
       }
       const doctypeName = readXmlName(
         document,
         skipXmlWhitespace(document, position + 9)
       );
-      if ((doctypeName == null ? void 0 : doctypeName.name.toLowerCase()) !== "svg") {
+      if (doctypeName?.name.toLowerCase() !== "svg") {
         return false;
       }
       const doctypeEnd = findDoctypeEnd(document, doctypeName.end);
@@ -903,8 +1037,7 @@ function readXmlName(value, position) {
   };
 }
 function skipXmlWhitespace(value, position) {
-  var _a;
-  while (/[\t\n\r ]/.test((_a = value[position]) != null ? _a : "")) {
+  while (/[\t\n\r ]/.test(value[position] ?? "")) {
     position += 1;
   }
   return position;
@@ -988,64 +1121,67 @@ function collectWarnings({
   }
   return warnings;
 }
-var svgUsageSchema = z2.object({
-  total_tokens: z2.number().int().nonnegative(),
-  input_tokens: z2.number().int().nonnegative(),
-  output_tokens: z2.number().int().nonnegative()
+var svgUsageSchema = z3.object({
+  total_tokens: z3.number().int().nonnegative(),
+  input_tokens: z3.number().int().nonnegative(),
+  output_tokens: z3.number().int().nonnegative()
 });
-var svgDocumentSchema = z2.object({
-  svg: z2.string().min(1),
-  mime_type: z2.literal("image/svg+xml"),
-  loop_period_ms: z2.number().int().nonnegative().nullish(),
-  opening_animation_ms: z2.number().int().nonnegative().nullish()
+var svgDocumentSchema = z3.object({
+  svg: z3.string().min(1),
+  mime_type: z3.literal("image/svg+xml"),
+  loop_period_ms: z3.number().int().nonnegative().nullish(),
+  opening_animation_ms: z3.number().int().nonnegative().nullish()
 });
-var svgGenerationResponseSchema = z2.object({
-  id: z2.string().min(1),
-  created: z2.number().int().nonnegative(),
-  data: z2.array(svgDocumentSchema).min(1),
+var svgGenerationResponseSchema = z3.object({
+  id: z3.string().min(1),
+  created: z3.number().int().nonnegative(),
+  data: z3.array(svgDocumentSchema).min(1),
   usage: svgUsageSchema.nullish(),
-  credits: z2.number().int().nonnegative().nullish()
-});
-var quiveraiErrorSchema = z2.object({
-  status: z2.number().int(),
-  code: z2.string().min(1),
-  message: z2.string().min(1),
-  request_id: z2.string().min(1)
-});
-var quiveraiFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: quiveraiErrorSchema,
-  errorToMessage: (error) => error.message,
-  isRetryable: (response) => response.status === 429 || response.status >= 500
+  credits: z3.number().int().nonnegative().nullish()
 });
 
 // src/version.ts
-var VERSION = true ? "2.0.47" : "0.0.0-test";
+var VERSION = true ? "2.0.50" : "0.0.0-test";
 
 // src/quiverai-provider.ts
 var defaultBaseURL = "https://api.quiver.ai/v1";
 function createQuiverAI(options = {}) {
-  var _a;
-  const baseURL = (_a = withoutTrailingSlash(
+  const baseURL = withoutTrailingSlash(
     loadOptionalSetting({
       settingValue: options.baseURL,
       environmentVariableName: "QUIVERAI_BASE_URL"
     })
-  )) != null ? _a : defaultBaseURL;
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      Authorization: `Bearer ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "QUIVERAI_API_KEY",
-        description: "QuiverAI"
-      })}`,
-      ...options.headers
-    },
-    `ai-sdk/quiverai/${VERSION}`
+  ) ?? defaultBaseURL;
+  const getHeaders = () => ({
+    Authorization: `Bearer ${loadApiKey({
+      apiKey: options.apiKey,
+      environmentVariableName: "QUIVERAI_API_KEY",
+      description: "QuiverAI"
+    })}`,
+    ...options.headers
+  });
+  const getImageHeaders = () => withUserAgentSuffix(getHeaders(), `ai-sdk/quiverai/${VERSION}`);
+  const responsesConfig = {
+    name: "quiverai",
+    url: `${baseURL}/responses`,
+    headers: getHeaders,
+    fetch: options.fetch,
+    failedResponseHandler: quiveraiFailedResponseHandler,
+    getResponseErrorMetadata: getQuiverAIResponseErrorMetadata,
+    strictResponseInput: true,
+    customToolId: "quiverai.custom",
+    structuredOutputs: false,
+    userAgentSuffix: `ai-sdk/quiverai/${VERSION}`
+  };
+  const responsesProvider = createOpenResponses2(responsesConfig);
+  const createLanguageModel = (modelId) => new QuiverAILanguageModel(
+    responsesProvider.languageModel(modelId),
+    responsesConfig
   );
   const createImageModel = (modelId) => new QuiverAIImageModel(modelId, {
     provider: "quiverai.image",
     baseURL,
-    headers: getHeaders,
+    headers: getImageHeaders,
     fetch: options.fetch
   });
   const embeddingModel = (modelId) => {
@@ -1054,19 +1190,17 @@ function createQuiverAI(options = {}) {
       modelType: "embeddingModel"
     });
   };
-  return {
-    specificationVersion: "v4",
-    image: createImageModel,
-    imageModel: createImageModel,
-    languageModel: (modelId) => {
-      throw new NoSuchModelError({
-        modelId,
-        modelType: "languageModel"
-      });
-    },
-    embeddingModel,
-    textEmbeddingModel: embeddingModel
+  const provider = function(modelId) {
+    return createLanguageModel(modelId);
   };
+  provider.specificationVersion = "v4";
+  provider.languageModel = createLanguageModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.embeddingModel = embeddingModel;
+  provider.textEmbeddingModel = embeddingModel;
+  provider.tools = responsesProvider.tools;
+  return provider;
 }
 var quiverai = createQuiverAI();
 export {