@ai-sdk/quiverai 2.0.46 → 2.0.48

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,170 @@ 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) {
+  var _a, _b;
+  const { reasoningEffort, reasoningSummary } = (_b = (_a = options.providerOptions) == null ? void 0 : _a.quiverai) != null ? _b : {};
+  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) => {
+            var _a2, _b2, _c;
+            if (part.type !== "reasoning") return part;
+            const metadata = (_c = (_a2 = part.providerOptions) == null ? void 0 : _a2.quiverai) != null ? _c : (_b2 = part.providerMetadata) == null ? void 0 : _b2.quiverai;
+            return {
+              ...part,
+              text: "",
+              providerOptions: {
+                ...part.providerOptions,
+                quiverai: {
+                  itemId: metadata == null ? void 0 : metadata.itemId,
+                  reasoningSummary: metadata == null ? void 0 : 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 +187,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 +287,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."
         });
@@ -167,13 +307,13 @@ function validateQuiverAIImageUrl(url) {
   try {
     parsed = new URL(url);
   } catch (e) {
-    throw new InvalidArgumentError({
+    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 +322,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 +331,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 +341,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."
     });
@@ -238,13 +378,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({
@@ -355,13 +495,13 @@ function toQuiverAIAnimationSource(image) {
     try {
       url = new URL(image.url);
     } catch (e) {
-      throw new InvalidArgumentError2({
+      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."
       });
@@ -376,7 +516,7 @@ function toQuiverAIAnimationSource(image) {
     try {
       bytes = convertBase64ToUint8Array2(encodedData);
     } catch (e) {
-      throw new InvalidArgumentError2({
+      throw new InvalidArgumentError3({
         argument: "files",
         message: "QuiverAI animate requires the source SVG string to be valid base64 or an SVG data URL."
       });
@@ -387,13 +527,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 +556,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,7 +575,7 @@ 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."
       });
@@ -443,7 +583,7 @@ function buildRequestBody({
     const references = files == null ? void 0 : 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 +618,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 +652,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 +698,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]}.`
     });
@@ -585,43 +725,43 @@ function buildEditRequestBody({
 }) {
   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,7 +775,7 @@ 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(
         ", "
@@ -680,7 +820,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 +840,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 +856,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."
     });
@@ -988,38 +1128,27 @@ 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.46" : "0.0.0-test";
+var VERSION = true ? "2.0.48" : "0.0.0-test";
 
 // src/quiverai-provider.ts
 var defaultBaseURL = "https://api.quiver.ai/v1";
@@ -1031,21 +1160,36 @@ function createQuiverAI(options = {}) {
       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}`
+  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 +1198,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 {