@ai-sdk/minimax 3.0.1 → 3.0.3

package/dist/index.js

@@ -10,14 +10,565 @@ import {
 } from "@ai-sdk/provider-utils";
 import { AnthropicLanguageModel } from "@ai-sdk/anthropic/internal";
 
+// src/minimax-video-model.ts
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  convertImageModelFileToDataUri,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  delay,
+  getFromApi,
+  getTopLevelMediaType,
+  parseProviderOptions,
+  postJsonToApi,
+  resolve
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+
+// src/minimax-video-model-options.ts
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var minimaxVideoRatios = [
+  "adaptive",
+  "21:9",
+  "16:9",
+  "4:3",
+  "1:1",
+  "3:4",
+  "9:16"
+];
+var minimaxVideoResolutions = ["2K"];
+var minimaxVideoProviderOptions = z.object({
+  /**
+   * Output resolution.
+   */
+  resolution: z.enum(minimaxVideoResolutions).optional(),
+  /**
+   * Aspect ratio of the generated video. Overrides the top-level `aspectRatio`.
+   */
+  ratio: z.enum(minimaxVideoRatios).optional(),
+  /**
+   * Reference audio URLs for reference-to-video generation.
+   */
+  referenceAudioUrls: z.array(z.string()).optional(),
+  /**
+   * Whether to embed an AIGC watermark in the output. Defaults to `false`.
+   */
+  aigcWatermark: z.boolean().optional(),
+  /**
+   * Interval in milliseconds between task status polls. Default: 10000.
+   */
+  pollIntervalMs: z.number().int().positive().optional(),
+  /**
+   * Maximum time in milliseconds to poll before timing out. Default: 600000.
+   */
+  pollTimeoutMs: z.number().int().positive().optional()
+});
+var minimaxVideoModelOptionsSchema = lazySchema(
+  () => zodSchema(minimaxVideoProviderOptions)
+);
+
+// src/minimax-video-model.ts
+var DEFAULT_RESOLUTION = "2K";
+var DEFAULT_ASPECT_RATIO = "16:9";
+var DEFAULT_POLL_INTERVAL_MS = 1e4;
+var DEFAULT_POLL_TIMEOUT_MS = 6e5;
+var MIN_DURATION_SECONDS = 5;
+var MAX_DURATION_SECONDS = 15;
+var MAX_REFERENCE_IMAGES = 9;
+var MAX_REFERENCE_VIDEOS = 3;
+var MAX_REFERENCE_AUDIOS = 3;
+var allowedRatios = new Set(minimaxVideoRatios);
+var allowedResolutions = new Set(minimaxVideoResolutions);
+var RESOLUTION_MAP = {
+  // Square
+  "2048x2048": "2K",
+  // Landscape
+  "2560x1080": "2K",
+  "2560x1440": "2K",
+  "2048x1536": "2K",
+  // Portrait
+  "1440x2560": "2K",
+  "1536x2048": "2K"
+};
+function resolveTopLevelResolution(resolution) {
+  const named = resolution.toUpperCase();
+  return allowedResolutions.has(named) ? named : RESOLUTION_MAP[resolution];
+}
+function nonImageFrameMediaType(file) {
+  if (file.mediaType == null) {
+    return void 0;
+  }
+  const topLevelMediaType = getTopLevelMediaType(file.mediaType);
+  return topLevelMediaType === "image" ? void 0 : topLevelMediaType;
+}
+var MiniMaxVideoModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+    this.maxVideosPerCall = 1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const warnings = [];
+    const minimaxOptions = await parseProviderOptions({
+      provider: "minimax",
+      providerOptions: options.providerOptions,
+      schema: minimaxVideoModelOptionsSchema
+    });
+    if (options.fps != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "fps",
+        details: "MiniMax-H3 does not support a custom frame rate."
+      });
+    }
+    if (options.seed != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "seed",
+        details: "MiniMax-H3 does not support a seed."
+      });
+    }
+    if (options.n != null && options.n > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: "n",
+        details: "MiniMax-H3 generates a single video per call. Only 1 video will be generated."
+      });
+    }
+    if (options.generateAudio != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "generateAudio",
+        details: "The MiniMax-H3 API does not expose an audio parameter. The generateAudio option was ignored."
+      });
+    }
+    let resolution = minimaxOptions == null ? void 0 : minimaxOptions.resolution;
+    if (options.resolution != null) {
+      const mapped = resolveTopLevelResolution(options.resolution);
+      if (resolution != null) {
+        if (mapped == null) {
+          warnings.push({
+            type: "unsupported",
+            feature: "resolution",
+            details: `Unrecognized resolution "${options.resolution}". MiniMax-H3 only supports "2K", so providerOptions.minimax.resolution ("${resolution}") was used instead.`
+          });
+        }
+      } else if (mapped != null) {
+        resolution = mapped;
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "resolution",
+          details: `Unrecognized resolution "${options.resolution}". MiniMax-H3 only supports "2K".`
+        });
+      }
+    }
+    resolution != null ? resolution : resolution = DEFAULT_RESOLUTION;
+    const content = [
+      { type: "text", text: (_d = options.prompt) != null ? _d : "" }
+    ];
+    let sentImageCount = 0;
+    const sentReferenceVideoUrls = [];
+    const firstFrameImage = (_f = (_e = options.frameImages) == null ? void 0 : _e.find(
+      (frame) => frame.frameType === "first_frame"
+    )) == null ? void 0 : _f.image;
+    let firstFrame = firstFrameImage != null ? firstFrameImage : options.image;
+    let lastFrame = (_h = (_g = options.frameImages) == null ? void 0 : _g.find(
+      (frame) => frame.frameType === "last_frame"
+    )) == null ? void 0 : _h.image;
+    const firstFrameMediaType = firstFrame != null ? nonImageFrameMediaType(firstFrame) : void 0;
+    if (firstFrame != null && firstFrameMediaType != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: firstFrameImage != null ? "frameImages" : "image",
+        details: firstFrameMediaType === "video" ? "MiniMax-H3 does not accept a video as a frame image. The video was ignored." : `MiniMax-H3 only accepts an image as a frame image; the "${firstFrame.mediaType}" file was ignored.`
+      });
+      firstFrame = void 0;
+    }
+    if (lastFrame != null) {
+      if (firstFrame == null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "frameImages",
+          details: "MiniMax-H3 requires a first_frame when a last_frame is provided. The last_frame was ignored."
+        });
+        lastFrame = void 0;
+      } else {
+        const lastFrameMediaType = nonImageFrameMediaType(lastFrame);
+        if (lastFrameMediaType != null) {
+          warnings.push({
+            type: "unsupported",
+            feature: "frameImages",
+            details: lastFrameMediaType === "video" ? "MiniMax-H3 does not accept a video as a frame image. The last_frame video was ignored." : `MiniMax-H3 only accepts an image as a frame image; the "${lastFrame.mediaType}" last_frame was ignored.`
+          });
+          lastFrame = void 0;
+        }
+      }
+    }
+    const usesFrameImages = firstFrame != null || lastFrame != null;
+    const referenceFiles = (_i = options.inputReferences) != null ? _i : [];
+    const referenceAudioUrls = (_j = minimaxOptions == null ? void 0 : minimaxOptions.referenceAudioUrls) != null ? _j : [];
+    const usesReferences = referenceFiles.length > 0 || referenceAudioUrls.length > 0;
+    if (usesFrameImages) {
+      if (firstFrame != null) {
+        content.push({
+          type: "image_url",
+          image_url: { url: convertImageModelFileToDataUri(firstFrame) },
+          role: "first_frame"
+        });
+        sentImageCount++;
+      }
+      if (lastFrame != null) {
+        content.push({
+          type: "image_url",
+          image_url: { url: convertImageModelFileToDataUri(lastFrame) },
+          role: "last_frame"
+        });
+        sentImageCount++;
+      }
+      if (usesReferences) {
+        warnings.push({
+          type: "unsupported",
+          feature: "inputReferences",
+          details: "MiniMax-H3 cannot combine frame images with reference inputs. The references were ignored."
+        });
+      }
+    } else if (usesReferences) {
+      const referenceImages = [];
+      const referenceVideos = [];
+      for (const file of referenceFiles) {
+        const topLevelMediaType = file.mediaType != null ? getTopLevelMediaType(file.mediaType) : void 0;
+        if (topLevelMediaType === "video") {
+          referenceVideos.push(file);
+        } else if (topLevelMediaType === "image") {
+          referenceImages.push(file);
+        } else if (topLevelMediaType == null) {
+          warnings.push({
+            type: "unsupported",
+            feature: "inputReferences",
+            details: 'MiniMax-H3 requires an explicit mediaType to route URL references as video or image. Pass { data: url, mediaType: "video/mp4" } for video references. The reference was treated as an image.'
+          });
+          referenceImages.push(file);
+        } else {
+          warnings.push({
+            type: "unsupported",
+            feature: "inputReferences",
+            details: `MiniMax-H3 only accepts image and video references; the "${file.mediaType}" reference was ignored. Pass reference audio via providerOptions.minimax.referenceAudioUrls.`
+          });
+        }
+      }
+      for (const image of referenceImages.slice(0, MAX_REFERENCE_IMAGES)) {
+        content.push({
+          type: "image_url",
+          image_url: { url: convertImageModelFileToDataUri(image) },
+          role: "reference_image"
+        });
+        sentImageCount++;
+      }
+      if (referenceImages.length > MAX_REFERENCE_IMAGES) {
+        warnings.push({
+          type: "unsupported",
+          feature: "inputReferences",
+          details: `MiniMax-H3 accepts at most ${MAX_REFERENCE_IMAGES} reference images. Extra images were ignored.`
+        });
+      }
+      for (const video of referenceVideos.slice(0, MAX_REFERENCE_VIDEOS)) {
+        const url = convertImageModelFileToDataUri(video);
+        content.push({
+          type: "video_url",
+          video_url: { url },
+          role: "reference_video"
+        });
+        if (video.type === "url") {
+          sentReferenceVideoUrls.push(url);
+        }
+      }
+      if (referenceVideos.length > MAX_REFERENCE_VIDEOS) {
+        warnings.push({
+          type: "unsupported",
+          feature: "inputReferences",
+          details: `MiniMax-H3 accepts at most ${MAX_REFERENCE_VIDEOS} reference videos. Extra videos were ignored.`
+        });
+      }
+      if (referenceAudioUrls.length > 0) {
+        if (referenceImages.length === 0 && referenceVideos.length === 0) {
+          warnings.push({
+            type: "unsupported",
+            feature: "referenceAudioUrls",
+            details: "MiniMax-H3 reference audio must be paired with at least one reference image or video. The audio was ignored."
+          });
+        } else {
+          for (const url of referenceAudioUrls.slice(0, MAX_REFERENCE_AUDIOS)) {
+            content.push({
+              type: "audio_url",
+              audio_url: { url },
+              role: "reference_audio"
+            });
+          }
+          if (referenceAudioUrls.length > MAX_REFERENCE_AUDIOS) {
+            warnings.push({
+              type: "unsupported",
+              feature: "referenceAudioUrls",
+              details: `MiniMax-H3 accepts at most ${MAX_REFERENCE_AUDIOS} reference audios. Extra audios were ignored.`
+            });
+          }
+        }
+      }
+    }
+    const isTextToVideo = content.length === 1;
+    let ratio = minimaxOptions == null ? void 0 : minimaxOptions.ratio;
+    if (ratio == null && options.aspectRatio != null) {
+      if (allowedRatios.has(options.aspectRatio)) {
+        ratio = options.aspectRatio;
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "aspectRatio",
+          details: isTextToVideo ? `MiniMax-H3 does not support the aspect ratio "${options.aspectRatio}". Using the default (${DEFAULT_ASPECT_RATIO}).` : `MiniMax-H3 does not support the aspect ratio "${options.aspectRatio}". Using the provider default (adaptive).`
+        });
+        if (isTextToVideo) {
+          ratio = DEFAULT_ASPECT_RATIO;
+        }
+      }
+    }
+    if (ratio === "adaptive" && isTextToVideo) {
+      warnings.push({
+        type: "unsupported",
+        feature: "aspectRatio",
+        details: `MiniMax-H3 text-to-video does not support the adaptive aspect ratio. Using the default (${DEFAULT_ASPECT_RATIO}).`
+      });
+      ratio = DEFAULT_ASPECT_RATIO;
+    }
+    if (usesFrameImages && ratio != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "aspectRatio",
+        details: "MiniMax-H3 derives the aspect ratio from the frame image; the requested ratio was ignored."
+      });
+      ratio = void 0;
+    }
+    if (ratio == null && isTextToVideo) {
+      ratio = DEFAULT_ASPECT_RATIO;
+    }
+    let duration = (_k = options.duration) != null ? _k : MIN_DURATION_SECONDS;
+    if (options.duration != null) {
+      if (!Number.isInteger(duration)) {
+        duration = Math.round(duration);
+        warnings.push({
+          type: "unsupported",
+          feature: "duration",
+          details: `MiniMax-H3 requires a whole number of seconds. The requested duration of ${options.duration} was rounded to ${duration}.`
+        });
+      }
+      if (duration > MAX_DURATION_SECONDS) {
+        warnings.push({
+          type: "unsupported",
+          feature: "duration",
+          details: `MiniMax-H3 supports at most ${MAX_DURATION_SECONDS} seconds. The requested duration of ${options.duration} was clamped to ${MAX_DURATION_SECONDS}.`
+        });
+        duration = MAX_DURATION_SECONDS;
+      } else if (duration < MIN_DURATION_SECONDS) {
+        warnings.push({
+          type: "unsupported",
+          feature: "duration",
+          details: `MiniMax-H3 requires at least ${MIN_DURATION_SECONDS} seconds. The requested duration of ${options.duration} was clamped to ${MIN_DURATION_SECONDS}.`
+        });
+        duration = MIN_DURATION_SECONDS;
+      }
+    }
+    const body = {
+      model: this.modelId,
+      content,
+      resolution,
+      duration
+    };
+    if (ratio != null) {
+      body.ratio = ratio;
+    }
+    if ((minimaxOptions == null ? void 0 : minimaxOptions.aigcWatermark) != null) {
+      body.aigc_watermark = minimaxOptions.aigcWatermark;
+    }
+    const baseURL = this.config.baseURL;
+    const { value: createResponse } = await postJsonToApi({
+      url: `${baseURL}/v2/video_generation`,
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers
+      ),
+      body,
+      failedResponseHandler: minimaxVideoFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        minimaxCreateVideoResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const taskId = createResponse.task_id;
+    if (!taskId) {
+      throw new AISDKError({
+        name: "MINIMAX_VIDEO_GENERATION_ERROR",
+        message: `No task_id returned from the MiniMax API. Response: ${JSON.stringify(createResponse)}`
+      });
+    }
+    const pollIntervalMs = (_l = minimaxOptions == null ? void 0 : minimaxOptions.pollIntervalMs) != null ? _l : DEFAULT_POLL_INTERVAL_MS;
+    const pollTimeoutMs = (_m = minimaxOptions == null ? void 0 : minimaxOptions.pollTimeoutMs) != null ? _m : DEFAULT_POLL_TIMEOUT_MS;
+    const startTime = Date.now();
+    let responseHeaders;
+    while (true) {
+      await delay(pollIntervalMs, { abortSignal: options.abortSignal });
+      if (Date.now() - startTime > pollTimeoutMs) {
+        throw new AISDKError({
+          name: "MINIMAX_VIDEO_GENERATION_TIMEOUT",
+          message: `MiniMax video generation timed out after ${pollTimeoutMs}ms. Task ID: ${taskId}`
+        });
+      }
+      const { value: statusResponse, responseHeaders: pollHeaders } = await getFromApi({
+        url: `${baseURL}/v2/query/video_generation/${taskId}`,
+        validateUrl: false,
+        headers: combineHeaders(
+          await resolve(this.config.headers),
+          options.headers
+        ),
+        successfulResponseHandler: createJsonResponseHandler(
+          minimaxVideoStatusResponseSchema
+        ),
+        failedResponseHandler: minimaxVideoFailedResponseHandler,
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch
+      });
+      responseHeaders = pollHeaders;
+      const task = statusResponse.task;
+      switch (task.status) {
+        case "succeeded": {
+          const url = (_n = task.content) == null ? void 0 : _n.url;
+          if (!url) {
+            throw new AISDKError({
+              name: "MINIMAX_VIDEO_GENERATION_ERROR",
+              message: `MiniMax video generation completed but no video URL was returned. Task ID: ${taskId}`
+            });
+          }
+          return {
+            videos: [
+              {
+                type: "url",
+                url,
+                mediaType: "video/mp4"
+              }
+            ],
+            warnings,
+            response: {
+              timestamp: currentDate,
+              modelId: this.modelId,
+              headers: responseHeaders
+            },
+            providerMetadata: {
+              minimax: {
+                taskId,
+                videoUrl: url,
+                resolvedInputs: {
+                  imageCount: sentImageCount,
+                  referenceVideoUrls: sentReferenceVideoUrls
+                },
+                ...task.duration != null ? { duration: task.duration } : {},
+                ...task.ratio != null ? { ratio: task.ratio } : {},
+                ...task.resolution != null ? { resolution: task.resolution } : {},
+                ...task.usage != null ? {
+                  usage: {
+                    totalSeconds: task.usage.total_seconds,
+                    inputSeconds: task.usage.input_seconds,
+                    outputSeconds: task.usage.output_seconds
+                  }
+                } : {}
+              }
+            }
+          };
+        }
+        case "failed": {
+          throw new AISDKError({
+            name: "MINIMAX_VIDEO_GENERATION_FAILED",
+            message: `MiniMax video generation failed${((_o = task.error) == null ? void 0 : _o.message) ? `: ${task.error.message}` : ""}${((_p = task.error) == null ? void 0 : _p.code) != null ? ` (${task.error.code})` : ""}. Task ID: ${taskId}`
+          });
+        }
+        case "cancelled": {
+          throw new AISDKError({
+            name: "MINIMAX_VIDEO_GENERATION_CANCELLED",
+            message: `MiniMax video generation was cancelled. Task ID: ${taskId}`
+          });
+        }
+        case "expired": {
+          throw new AISDKError({
+            name: "MINIMAX_VIDEO_GENERATION_EXPIRED",
+            message: `MiniMax video generation request expired. Task ID: ${taskId}`
+          });
+        }
+        // 'queued' | 'running' | unknown → keep polling.
+        default:
+          break;
+      }
+    }
+  }
+};
+var minimaxCreateVideoResponseSchema = z2.object({
+  task_id: z2.string().nullish()
+});
+var minimaxVideoStatusResponseSchema = z2.object({
+  task: z2.object({
+    id: z2.string().nullish(),
+    status: z2.string().nullish(),
+    content: z2.object({
+      url: z2.string().nullish()
+    }).nullish(),
+    resolution: z2.string().nullish(),
+    duration: z2.number().nullish(),
+    ratio: z2.string().nullish(),
+    usage: z2.object({
+      total_seconds: z2.number().nullish(),
+      input_seconds: z2.number().nullish(),
+      output_seconds: z2.number().nullish()
+    }).nullish(),
+    error: z2.object({
+      code: z2.union([z2.string(), z2.number()]).nullish(),
+      message: z2.string().nullish()
+    }).nullish()
+  })
+});
+var minimaxVideoErrorSchema = z2.object({
+  type: z2.string().nullish(),
+  error: z2.object({
+    type: z2.string().nullish(),
+    message: z2.string().nullish(),
+    http_code: z2.union([z2.string(), z2.number()]).nullish()
+  }).nullish(),
+  request_id: z2.string().nullish()
+});
+var minimaxVideoFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: minimaxVideoErrorSchema,
+  errorToMessage: (data) => {
+    var _a, _b;
+    return (_b = (_a = data.error) == null ? void 0 : _a.message) != null ? _b : "MiniMax video generation error";
+  }
+});
+
 // src/version.ts
-var VERSION = true ? "3.0.1" : "0.0.0-test";
+var VERSION = true ? "3.0.3" : "0.0.0-test";
 
 // src/minimax-provider.ts
 var defaultBaseURL = "https://api.minimax.io/anthropic/v1";
+var defaultVideoBaseURL = "https://api.minimax.io";
 function createMiniMax(options = {}) {
-  var _a, _b;
+  var _a, _b, _c, _d;
   const baseURL = (_b = withoutTrailingSlash((_a = options.baseURL) != null ? _a : defaultBaseURL)) != null ? _b : defaultBaseURL;
+  const videoBaseURL = (_d = withoutTrailingSlash((_c = options.videoBaseURL) != null ? _c : defaultVideoBaseURL)) != null ? _d : defaultVideoBaseURL;
   const getHeaders = () => withUserAgentSuffix(
     {
       "anthropic-version": "2023-06-01",
@@ -38,10 +589,29 @@ function createMiniMax(options = {}) {
     generateId,
     supportedUrls: () => ({})
   });
+  const getVideoHeaders = () => withUserAgentSuffix(
+    {
+      Authorization: `Bearer ${loadApiKey({
+        apiKey: options.apiKey,
+        environmentVariableName: "MINIMAX_API_KEY",
+        description: "MiniMax API key"
+      })}`,
+      ...options.headers
+    },
+    `ai-sdk/minimax/${VERSION}`
+  );
+  const createVideoModel = (modelId) => new MiniMaxVideoModel(modelId, {
+    provider: "minimax.video",
+    baseURL: videoBaseURL,
+    headers: getVideoHeaders,
+    fetch: options.fetch
+  });
   const provider = (modelId) => createChatModel(modelId);
   provider.specificationVersion = "v4";
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
+  provider.video = createVideoModel;
+  provider.videoModel = createVideoModel;
   provider.embeddingModel = (modelId) => {
     throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
   };