From 7461d1520872c8a845e6d43d79e7c92ee8db02bb Mon Sep 17 00:00:00 2001
From: Aiden Cline <63023139+rekram1-node@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:41:32 -0500
Subject: [PATCH] feat(ai): add MiniMax image generation (#59929)

---
 packages/ai/README.md                         |  28 ++-
 packages/ai/package.json                      |   1 +
 packages/ai/src/protocols/minimax-images.ts   | 215 ++++++++++++++++
 packages/ai/src/providers/minimax.ts          |  40 ++-
 packages/ai/src/providers/minimax/images.ts   |   4 +
 packages/ai/test/exports.test.ts              |   3 +
 .../minimax-images/generates-an-image.json    |  32 +++
 .../generates-from-a-subject-reference.json   |  32 +++
 .../test/provider/media-entrypoints.test.ts   |   9 +
 .../provider/minimax-images.recorded.test.ts  |  52 ++++
 .../ai/test/provider/minimax-images.test.ts   | 233 ++++++++++++++++++
 packages/core/src/provider.ts                 |   1 +
 12 files changed, 635 insertions(+), 15 deletions(-)
 create mode 100644 packages/ai/src/protocols/minimax-images.ts
 create mode 100644 packages/ai/src/providers/minimax/images.ts
 create mode 100644 packages/ai/test/fixtures/recordings/minimax-images/generates-an-image.json
 create mode 100644 packages/ai/test/fixtures/recordings/minimax-images/generates-from-a-subject-reference.json
 create mode 100644 packages/ai/test/provider/minimax-images.recorded.test.ts
 create mode 100644 packages/ai/test/provider/minimax-images.test.ts

diff --git a/packages/ai/README.md b/packages/ai/README.md
index 7b2f445b3508..f7ae791fa028 100644
--- a/packages/ai/README.md
+++ b/packages/ai/README.md
@@ -586,7 +586,9 @@ M2.x models always think, even when a disabling option is supplied. For tool con
 `response.message` in history before adding `Message.tool(...)` results; this preserves reasoning and any signatures.
 
 The default API bases are `https://api.minimax.io/anthropic/v1` for Messages and `https://api.minimax.io/v1` for
-Chat and Responses. `configure({ baseURL })` replaces the selected API's base, including its version prefix.
+Chat, Responses and Images. `configure({ baseURL })` replaces the selected API's base, including its version prefix;
+use `https://api.minimax.cn/v1` for the mainland China platform. `minimax.image("image-01")` (also
+`@opencode/ai/providers/minimax/images`) generates images; see [MiniMax images](#minimax-images).
 
 ## Meta
 
@@ -704,6 +706,7 @@ table before swapping only the `model`:
 | Meta                  | ✓   | ✓ (hint)             | ignored               | ✓                                | `size`, `outputFormat`                             |
 | Z.ai                  | ✗   | width × height       | width × height        | ✗                                | `size`                                             |
 | Alibaba               | ✓   | width × height       | width × height        | ✓                                | `size`, `seed`                                     |
+| MiniMax               | ✓   | preset or w × h⁴     | preset or w × h⁴      | 1 (portrait subject)             | `aspect_ratio`, `width`, `height`, `seed`          |
 | Black Forest Labs     | 1   | per model            | width × height models | per model (1–8)                  | `width`, `height`, `seed`, `output_format`, `mask` |
 | fal                   | ✓   | per model            | per model             | 1 (several on `/edit`, `/multi`) | `image_size`, `seed`, `output_format`, `mask`      |
 | Replicate             | ✗   | ✗                    | ✗                     | ✗ (use `providerOptions`)        | everything                                         |
@@ -719,7 +722,8 @@ fixed sizes. `providerOptions.size` replaces `aspect` and `resolution`, so setti
 forwards `outputFormat` but does not apply it, so the returned bytes keep the upstream model's own format. ² Workers AI
 `@cf/black-forest-labs/flux-1-schnell` takes no size, and the provider rejects it. ³ Non-OpenAI gateway models
 (`bfl/flux-2-pro`) get a computed width × height, which the gateway passes through; models with a fixed list, such as
-Recraft, reject sizes outside it.
+Recraft, reject sizes outside it. ⁴ MiniMax sends its `aspect_ratio` preset for a preset aspect at about `1K` and an
+exact width × height (512–2048 px, steps of 8) otherwise; `image-01-live` takes only the presets, minus `21:9`.
 
 `Media.Asset` is the one asset type shared by image requests, image responses, LLM messages, and tool results.
 `asset.source` is the serializable `Media.Source` (`bytes`, `base64`, `url`, or `ref`); `asset.bytes()`,
@@ -848,6 +852,26 @@ Z.ai does not include trustworthy MIME metadata for output URLs, so generated im
 `application/octet-stream` until materialized. Output URLs expire after 30 days; call `asset.materialize()` and
 persist the bytes promptly if they must remain available.
 
+### MiniMax images
+
+```ts
+import { MiniMax } from "@opencode/ai/providers"
+
+const minimax = Image.generate({
+  model: MiniMax.configure({ apiKey }).image("image-01"),
+  prompt,
+  n: 2,
+  aspect: "16:9",
+  images: [Media.url("https://example.com/portrait.jpg")], // optional subject reference
+  providerOptions: { promptOptimizer: true, seed: 42 },
+})
+```
+
+The reference image is sent as a `character` subject, so it should be a single front-facing portrait. Images come
+back inline (`responseFormat: "base64"` by default); `responseFormat: "url"` returns links that expire after 24 hours
+and carry no MIME type until materialized. MiniMax status codes map to typed errors; code 1026 is a `ContentPolicy`
+error.
+
 ### Partial images
 
 OpenAI's GPT image models stream previews. `Image.stream` sends `stream: true` with `partialImages` (0–3, default 2)
diff --git a/packages/ai/package.json b/packages/ai/package.json
index f07d18b1ab7a..63815a853648 100644
--- a/packages/ai/package.json
+++ b/packages/ai/package.json
@@ -79,6 +79,7 @@
     "./providers/meta/responses": "./src/providers/meta/responses.ts",
     "./providers/minimax": "./src/providers/minimax.ts",
     "./providers/minimax/chat": "./src/providers/minimax/chat.ts",
+    "./providers/minimax/images": "./src/providers/minimax/images.ts",
     "./providers/minimax/messages": "./src/providers/minimax/messages.ts",
     "./providers/minimax/responses": "./src/providers/minimax/responses.ts",
     "./providers/mistral": "./src/providers/mistral.ts",
diff --git a/packages/ai/src/protocols/minimax-images.ts b/packages/ai/src/protocols/minimax-images.ts
new file mode 100644
index 000000000000..a8e7b8f12a27
--- /dev/null
+++ b/packages/ai/src/protocols/minimax-images.ts
@@ -0,0 +1,215 @@
+import { Duration, Effect, Schema } from "effect"
+import type { HttpClientResponse } from "effect/http"
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
+import { Media } from "../media.js"
+import { MediaProtocol } from "../route/media-protocol.js"
+import { MediaRoute } from "../route/media.js"
+import { AIError, QuotaExceededError, mergeJsonRecords, type OpenString } from "../schema/index.js"
+import { ProviderShared, optionalNull } from "./shared.js"
+import { ImageSizing } from "./utils/image-sizing.js"
+import { MediaInput } from "./utils/media-input.js"
+
+const route = MediaProtocol.identity({ id: "minimax-images", name: "MiniMax Images", provider: "minimax" })
+export const DEFAULT_BASE_URL = "https://api.minimax.io/v1"
+export const PATH = "/image_generation"
+const OUTPUT_RETENTION = Duration.hours(24)
+
+// ---------------------------------------------------------------------------
+// 1. Public model input
+// ---------------------------------------------------------------------------
+
+/** Provider-native options. Common `aspect` and `resolution` lower to `aspect_ratio` or `width` and `height`. */
+export type MiniMaxImageOptions = {
+  /** Defaults to `base64`, which returns the bytes inline; `url` links expire after 24 hours. */
+  readonly responseFormat?: OpenString<"url" | "base64">
+  readonly seed?: number
+  readonly promptOptimizer?: boolean
+  /** Native preset; it replaces `aspect` and `resolution`. */
+  readonly aspect_ratio?: string
+  /** Native size, 512 to 2048 in steps of 8 (`image-01` only); it replaces `aspect` and `resolution`. */
+  readonly width?: number
+  readonly height?: number
+} & Record<string, unknown>
+
+export type Request = ImageRequestFor<MiniMaxImageOptions>
+
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+
+const MiniMaxImageResponse = Schema.Struct({
+  id: optionalNull(Schema.String),
+  data: optionalNull(
+    Schema.Struct({
+      image_urls: optionalNull(Schema.Array(Schema.String)),
+      image_base64: optionalNull(Schema.Array(Schema.String)),
+    }),
+  ),
+  metadata: optionalNull(
+    Schema.Struct({
+      success_count: optionalNull(Schema.Union([Schema.Number, Schema.String])),
+      failed_count: optionalNull(Schema.Union([Schema.Number, Schema.String])),
+    }),
+  ),
+  base_resp: optionalNull(
+    Schema.Struct({
+      status_code: Schema.Number,
+      status_msg: optionalNull(Schema.String),
+    }),
+  ),
+})
+
+const FAILURE: Readonly<Record<string, MediaProtocol.Failure>> = {
+  1002: "RateLimit",
+  1004: "Authentication",
+  2013: "InvalidRequest",
+  2049: "Authentication",
+}
+const INSUFFICIENT_BALANCE = 1008
+const CONTENT_POLICY = 1026
+
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+
+/** MiniMax's `aspect_ratio` presets and the sizes it renders them at. */
+const PRESETS: Record<string, ImageSizing.Size> = {
+  "1:1": { width: 1024, height: 1024 },
+  "16:9": { width: 1280, height: 720 },
+  "4:3": { width: 1152, height: 864 },
+  "3:2": { width: 1248, height: 832 },
+  "2:3": { width: 832, height: 1248 },
+  "3:4": { width: 864, height: 1152 },
+  "9:16": { width: 720, height: 1280 },
+  "21:9": { width: 1344, height: 576 },
+}
+
+const LIMITS = { multiple: 8, minEdge: 512, maxEdge: 2048 }
+
+const nativeOptions = (options: MiniMaxImageOptions = {}) => {
+  const { responseFormat, promptOptimizer, ...native } = options
+  return { response_format: responseFormat ?? "base64", prompt_optimizer: promptOptimizer, ...native }
+}
+
+/** `image-01-live` rejects `21:9`. */
+const presets = (model: string) =>
+  model === "image-01" ? PRESETS : Object.fromEntries(Object.entries(PRESETS).filter(([key]) => key !== "21:9"))
+
+/** Presets render at about 1K, so they serve a preset aspect with no resolution or `1K`. */
+const preset = (request: Request) => {
+  const aspect = request.aspect ?? "1:1"
+  if (!Object.hasOwn(presets(request.model.id), aspect)) return undefined
+  if (request.resolution !== undefined && ImageSizing.tier(request.resolution) !== 1) return undefined
+  return aspect
+}
+
+/** Only `image-01` takes free `width` and `height`; other models render the presets alone. */
+const sizing = (request: Request) => {
+  if (!ImageSizing.isRequested(request)) return Effect.succeed({})
+  const aspect = preset(request)
+  if (aspect !== undefined) return Effect.succeed({ aspect_ratio: aspect })
+  if (request.model.id === "image-01") return ImageSizing.exact(route, request, LIMITS)
+  const available = presets(request.model.id)
+  const closest = ImageSizing.nearest(request, Object.values(available))
+  const name = Object.keys(available).find((key) => available[key] === closest)
+  return Effect.fail(
+    route.unsupported(
+      request.resolution === undefined ? "media.aspect" : "media.resolution",
+      `${request.model.id} can't render ${[request.aspect, request.resolution].filter((value) => value !== undefined).join(" at ")}; the closest size it takes is ${closest.width}x${closest.height} (${name}). Change aspect or resolution, or set aspect_ratio in providerOptions`,
+    ),
+  )
+}
+
+const isNativeSize = (options: MiniMaxImageOptions | undefined) =>
+  options?.aspect_ratio !== undefined || options?.width !== undefined || options?.height !== undefined
+
+// The API only takes a `character` (portrait) subject, one per request.
+const subject = (asset: Media.Asset) =>
+  ProviderShared.mediaReference(asset, undefined, `${route.name} input`).pipe(
+    Effect.map((item) => ({ type: "character", image_file: item.value })),
+  )
+
+const fromRequest = Effect.fn("MiniMaxImages.fromRequest")(function* (request: Request) {
+  if ((request.images?.length ?? 0) > 1)
+    return yield* route.unsupported("media.images", `${route.name} takes one subject reference image`)
+  if (isNativeSize(request.providerOptions) && ImageSizing.isRequested(request))
+    return yield* ProviderShared.invalidRequest(
+      "MiniMax providerOptions aspect_ratio, width and height replace aspect and resolution; set one or the other",
+    )
+  const references = yield* Effect.forEach(request.images ?? [], subject)
+  return MediaProtocol.json(
+    mergeJsonRecords(
+      {
+        model: request.model.id,
+        prompt: request.prompt,
+        subject_reference: references.length === 0 ? undefined : references,
+        n: request.n,
+        ...(yield* sizing(request)),
+      },
+      nativeOptions(request.providerOptions),
+      request.http?.body,
+    ) ?? {},
+  )
+})
+
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+
+const decodeDocument = route.decodeJson(MiniMaxImageResponse)
+
+const decodeResponse = Effect.fn("MiniMaxImages.decodeResponse")(function* (
+  response: HttpClientResponse.HttpClientResponse,
+) {
+  const output = yield* decodeDocument(response)
+  const decoded = output.value
+  // MiniMax answers errors with HTTP 200 and a non-zero `base_resp.status_code`.
+  const status = decoded.base_resp
+  if (status && status.status_code !== 0) {
+    const message = `${route.name} failed (${status.status_code}): ${status.status_msg ?? "unknown error"}`
+    if (status.status_code === CONTENT_POLICY) return yield* output.contentPolicy(message)
+    if (status.status_code === INSUFFICIENT_BALANCE)
+      return yield* new AIError({ reason: new QuotaExceededError({ message, body: output.body, http: output.http }) })
+    return yield* output.ended("failed", message, MediaProtocol.failure(FAILURE, status.status_code))
+  }
+  const images = [
+    ...(yield* Effect.forEach(decoded.data?.image_base64 ?? [], (data, index) =>
+      MediaInput.decodedAsset(output.invalid, `${route.name} result ${index}`, data, undefined),
+    )),
+    // MiniMax returns no content type for URLs; the media type resolves when the asset is materialized.
+    ...(yield* Effect.forEach(decoded.data?.image_urls ?? [], (url) =>
+      MediaProtocol.expiringUrl(url, OUTPUT_RETENTION),
+    )),
+  ]
+  const failed = Number(decoded.metadata?.failed_count ?? 0)
+  if (images.length === 0 && failed > 0)
+    return yield* output.contentPolicy(`${route.name} blocked ${failed} image(s) for content safety`)
+  if (images.length === 0) return yield* output.invalid(`${route.name} returned no images`)
+  return new ImageResponse({
+    images,
+    providerMetadata: {
+      minimax: {
+        id: decoded.id ?? undefined,
+        successCount: decoded.metadata?.success_count ?? undefined,
+        failedCount: decoded.metadata?.failed_count ?? undefined,
+      },
+    },
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+
+export const protocol = MediaProtocol.inline<Request, ImageResponse>(route, {
+  body: { from: fromRequest },
+  response: { decode: decodeResponse },
+})
+
+export const model = (input: MediaRoute.ModelInput) =>
+  ImageModel.fromRoute<MiniMaxImageOptions>({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input)
+
+export const MiniMaxImages = {
+  protocol,
+  model,
+} as const
diff --git a/packages/ai/src/providers/minimax.ts b/packages/ai/src/providers/minimax.ts
index a9eaba5a09d0..18c69016199c 100644
--- a/packages/ai/src/providers/minimax.ts
+++ b/packages/ai/src/providers/minimax.ts
@@ -1,6 +1,7 @@
 import { Effect, Schema } from "effect"
 import type { ProviderPackage } from "../provider-package.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
+import { MiniMaxImages, type MiniMaxImageOptions } from "../protocols/minimax-images.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { OpenResponses } from "../protocols/open-responses.js"
 import { ProviderShared } from "../protocols/shared.js"
@@ -8,8 +9,9 @@ import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
+import { MediaRoute } from "../route/media.js"
 import { Protocol } from "../route/protocol.js"
-import { ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
+import { ProviderID, type LLMRequest, type ModelID, type ProviderOptions } from "../schema/index.js"
 
 export const id = ProviderID.make("minimax")
 
@@ -46,6 +48,8 @@ export type Settings<Options = MessagesOptionsInput> = ProviderPackage.Settings
     readonly baseURL?: string
   }
 
+export type { MiniMaxImageOptions }
+
 const ChatOptions = Schema.Struct({
   thinking: Schema.optional(Schema.Struct({ type: Schema.String })),
   reasoningSplit: Schema.optional(Schema.Boolean),
@@ -106,10 +110,11 @@ export const routes = [messagesRoute, chatRoute, responsesRoute]
 
 export const configure = (input: Config = {}) => {
   const { apiKey: _apiKey, auth: _auth, baseURL, ...rest } = input
+  const auth = AuthOptions.bearer(input, "MINIMAX_API_KEY")
   const defaults = {
     ...rest,
     endpoint: baseURL === undefined ? undefined : { baseURL },
-    auth: AuthOptions.bearer(input, "MINIMAX_API_KEY"),
+    auth,
   }
   const messages = (modelID: string | ModelID) =>
     messagesRoute.with(defaults).model<MessagesOptionsInput>({ id: modelID })
@@ -120,25 +125,34 @@ export const configure = (input: Config = {}) => {
     })
   const responses = (modelID: string | ModelID) =>
     responsesRoute.with(defaults).model<ResponsesOptionsInput>({ id: modelID })
-  return { id, model: messages, messages, chat, responses, configure }
+  const media = MediaRoute.deployment(input, auth)
+  const image = (modelID: string | ModelID, providerOptions?: ProviderOptions) =>
+    MiniMaxImages.model({ ...media, id: modelID, providerOptions })
+  return { id, model: messages, messages, chat, responses, image, configure }
 }
 
 export const provider = configure()
 
-export const model: ProviderPackage.Model<Settings<MessagesOptionsInput>, MessagesOptionsInput> = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions }: Settings<MessagesOptionsInput> = {},
-) =>
-  configure({
+export const model: ProviderPackage.Model<Settings<MessagesOptionsInput>, MessagesOptionsInput> = (modelID, settings) =>
+  configure(config(settings)).model(modelID)
+export const imageModel = (modelID: string, settings?: Settings<MiniMaxImageOptions>) => {
+  const input = config(settings)
+  return configure(input).image(modelID, input.providerOptions)
+}
+
+export const messages = provider.messages
+export const chat = provider.chat
+export const responses = provider.responses
+export const image = provider.image
+
+function config({ apiKey, baseURL, body, headers, ...providerOptions }: Settings<{}> = {}) {
+  return {
     apiKey,
     baseURL,
     headers,
     http: body === undefined ? undefined : { body },
     providerOptions,
-  }).model(modelID)
-
-export const messages = provider.messages
-export const chat = provider.chat
-export const responses = provider.responses
+  }
+}
 
 export * as MiniMax from "./minimax.js"
diff --git a/packages/ai/src/providers/minimax/images.ts b/packages/ai/src/providers/minimax/images.ts
new file mode 100644
index 000000000000..784753d1c09c
--- /dev/null
+++ b/packages/ai/src/providers/minimax/images.ts
@@ -0,0 +1,4 @@
+import type { MiniMax } from "../minimax.js"
+
+export { imageModel as model } from "../minimax.js"
+export type Settings = MiniMax.Settings<MiniMax.MiniMaxImageOptions>
diff --git a/packages/ai/test/exports.test.ts b/packages/ai/test/exports.test.ts
index 0605645b0770..bab54c386cfc 100644
--- a/packages/ai/test/exports.test.ts
+++ b/packages/ai/test/exports.test.ts
@@ -36,6 +36,7 @@ import {
   Fireworks,
   Google,
   Meta,
+  MiniMax,
   OpenCode,
   OpenAI,
   OpenAICompatible,
@@ -179,6 +180,8 @@ describe("public exports", () => {
     expect(Meta.provider.image).toBe(Meta.image)
     expect(ZAI.configure({ apiKey: "fixture" }).image("glm-image").route.id).toBe("zai-images")
     expect(ZAI.provider.image).toBe(ZAI.image)
+    expect(MiniMax.configure({ apiKey: "fixture" }).image("image-01").route.id).toBe("minimax-images")
+    expect(MiniMax.provider.image).toBe(MiniMax.image)
     expect(Alibaba.configure({ region: "ap-southeast-1", apiKey: "fixture" }).image("qwen-image-2.0").route.id).toBe(
       "alibaba-images",
     )
diff --git a/packages/ai/test/fixtures/recordings/minimax-images/generates-an-image.json b/packages/ai/test/fixtures/recordings/minimax-images/generates-an-image.json
new file mode 100644
index 000000000000..7dc896d00930
--- /dev/null
+++ b/packages/ai/test/fixtures/recordings/minimax-images/generates-an-image.json
@@ -0,0 +1,32 @@
+{
+  "version": 1,
+  "metadata": {
+    "tags": [
+      "prefix:minimax-images",
+      "provider:minimax",
+      "protocol:minimax-images"
+    ],
+    "name": "minimax-images/generates-an-image",
+    "recordedAt": "2026-10-28T14:31:36.981Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.minimax.io/v1/image_generation",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"image-01\",\"prompt\":\"A simple flat red circle centered on a plain white background.\",\"width\":512,\"height\":512,\"response_format\":\"base64\"}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "application/json; charset=utf-8"
+        },
+        "body": "{\"id\":\"07313a409af3baeeaff6248b2369f641\",\"data\":{\"image_base64\":[\"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\"]},\"metadata\":{\"failed_count\":\"0\",\"success_count\":\"1\"},\"base_resp\":{\"status_code\":0,\"status_msg\":\"success\"}}"
+      }
+    }
+  ]
+}
diff --git a/packages/ai/test/fixtures/recordings/minimax-images/generates-from-a-subject-reference.json b/packages/ai/test/fixtures/recordings/minimax-images/generates-from-a-subject-reference.json
new file mode 100644
index 000000000000..72fec3003016
--- /dev/null
+++ b/packages/ai/test/fixtures/recordings/minimax-images/generates-from-a-subject-reference.json
@@ -0,0 +1,32 @@
+{
+  "version": 1,
+  "metadata": {
+    "tags": [
+      "prefix:minimax-images",
+      "provider:minimax",
+      "protocol:minimax-images"
+    ],
+    "name": "minimax-images/generates-from-a-subject-reference",
+    "recordedAt": "2026-10-28T14:31:50.310Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.minimax.io/v1/image_generation",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"image-01\",\"prompt\":\"The same woman reading a book in a quiet library, soft window light.\",\"subject_reference\":[{\"type\":\"character\",\"image_file\":\"https://cdn.hailuoai.com/prod/2025-08-12-17/video_cover/1754990600020238321-411603868533342214-cover.jpg\"}],\"width\":512,\"height\":512,\"response_format\":\"base64\"}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "application/json; charset=utf-8"
+        },
+        "body": "{\"id\":\"07313a49e806dfa36070e1a1438027e6\",\"data\":{\"image_base64\":[\"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\"]},\"metadata\":{\"failed_count\":\"0\",\"success_count\":\"1\"},\"base_resp\":{\"status_code\":0,\"status_msg\":\"success\"}}"
+      }
+    }
+  ]
+}
diff --git a/packages/ai/test/provider/media-entrypoints.test.ts b/packages/ai/test/provider/media-entrypoints.test.ts
index 8c8333b5c92c..73c5925aee77 100644
--- a/packages/ai/test/provider/media-entrypoints.test.ts
+++ b/packages/ai/test/provider/media-entrypoints.test.ts
@@ -142,6 +142,15 @@ const images: ReadonlyArray<Case<ImageModel>> = [
     url: "https://open.bigmodel.test/api/paas/v4/images/generations",
     auth: ["authorization", "Bearer zai-key"],
   },
+  {
+    name: "minimax",
+    load: async () => {
+      const { model } = await import("@opencode/ai/providers/minimax/images")
+      return model("image-01", { ...shared, apiKey: "minimax-key", baseURL: "https://api.minimax.cn/v1" })
+    },
+    url: "https://api.minimax.cn/v1/image_generation",
+    auth: ["authorization", "Bearer minimax-key"],
+  },
   {
     name: "alibaba",
     load: async () => {
diff --git a/packages/ai/test/provider/minimax-images.recorded.test.ts b/packages/ai/test/provider/minimax-images.recorded.test.ts
new file mode 100644
index 000000000000..fa25aa8a0072
--- /dev/null
+++ b/packages/ai/test/provider/minimax-images.recorded.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Image, Media } from "../../src/effect.js"
+import { MiniMax } from "../../src/providers.js"
+import { dimensions } from "../lib/image.js"
+import { recordedTests } from "../recorded-test.js"
+
+const model = MiniMax.configure({ apiKey: process.env.MINIMAX_API_KEY ?? "fixture" }).image("image-01")
+
+const recorded = recordedTests({
+  prefix: "minimax-images",
+  provider: "minimax",
+  protocol: "minimax-images",
+  requires: ["MINIMAX_API_KEY"],
+})
+
+describe("MiniMax Images recorded", () => {
+  recorded.effect("generates an image", () =>
+    Effect.gen(function* () {
+      const response = yield* Image.generate({
+        model,
+        prompt: "A simple flat red circle centered on a plain white background.",
+        aspect: "1:1",
+        resolution: "0.5K",
+      })
+
+      expect(response.images).toHaveLength(1)
+      expect(response.image.mediaType).toMatch(/^image\/(jpeg|png)$/)
+      expect(dimensions(yield* response.image.bytes())).toEqual({ width: 512, height: 512 })
+      expect(response.providerMetadata?.minimax).toBeDefined()
+    }),
+  )
+
+  recorded.effect("generates from a subject reference", () =>
+    Effect.gen(function* () {
+      const response = yield* Image.generate({
+        model,
+        prompt: "The same woman reading a book in a quiet library, soft window light.",
+        // MiniMax's own documentation portrait.
+        images: [
+          Media.url(
+            "https://cdn.hailuoai.com/prod/2025-08-12-17/video_cover/1754990600020238321-411603868533342214-cover.jpg",
+          ),
+        ],
+        resolution: "0.5K",
+      })
+
+      expect(response.images).toHaveLength(1)
+      expect(dimensions(yield* response.image.bytes())).toEqual({ width: 512, height: 512 })
+    }),
+  )
+})
diff --git a/packages/ai/test/provider/minimax-images.test.ts b/packages/ai/test/provider/minimax-images.test.ts
new file mode 100644
index 000000000000..bc921e2c6962
--- /dev/null
+++ b/packages/ai/test/provider/minimax-images.test.ts
@@ -0,0 +1,233 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { HttpClientRequest } from "effect/http"
+import { Image, ImageClient, Media } from "../../src/effect.js"
+import type { ImageRequestInput } from "../../src/image.js"
+import { MiniMax } from "../../src/providers.js"
+import { it } from "../lib/effect.js"
+import { dynamicResponse, fixedResponse } from "../lib/http.js"
+
+const minimax = MiniMax.configure({ apiKey: "test" })
+const imageResponse = JSON.stringify({ data: { image_urls: ["https://cdn.minimax.test/a.jpeg"] } })
+
+/** The JSON body MiniMax receives for a request. */
+const sent = (
+  request: Omit<ImageRequestInput<ReturnType<typeof minimax.image>>, "model" | "prompt">,
+  model = "image-01",
+) =>
+  Effect.gen(function* () {
+    let body: unknown
+    yield* Image.generate({ model: minimax.image(model), prompt: "test", ...request }).pipe(
+      Effect.provide(
+        ImageClient.layer.pipe(
+          Layer.provide(
+            dynamicResponse((input) => {
+              body = JSON.parse(input.text)
+              return Effect.succeed(input.respond(imageResponse, { headers: { "content-type": "application/json" } }))
+            }),
+          ),
+        ),
+      ),
+    )
+    return body
+  })
+
+const failure = (
+  request: Omit<ImageRequestInput<ReturnType<typeof minimax.image>>, "model" | "prompt">,
+  model = "image-01",
+  response = imageResponse,
+) =>
+  Image.generate({ model: minimax.image(model), prompt: "test", ...request }).pipe(
+    Effect.provide(
+      ImageClient.layer.pipe(
+        Layer.provide(fixedResponse(response, { headers: { "content-type": "application/json" } })),
+      ),
+    ),
+    Effect.flip,
+  )
+
+describe("MiniMax Images", () => {
+  it.effect("generates through the MiniMax image API", () =>
+    Effect.gen(function* () {
+      const response = yield* Image.generate({
+        model: MiniMax.configure({
+          apiKey: "test",
+          baseURL: "https://api.minimax.test/v1",
+          headers: { "x-default": "yes" },
+          http: { body: { configured: true } },
+        }).image("image-01"),
+        prompt: "A girl stands by the library window",
+        n: 2,
+        aspect: "16:9",
+        images: [Media.url("https://example.test/face.jpg")],
+        providerOptions: { responseFormat: "url", response_format: "base64", promptOptimizer: true, seed: 7 },
+        http: { headers: { "x-request": "yes" }, body: { future_option: "http" } },
+      })
+
+      expect(response.images).toHaveLength(2)
+      expect(yield* response.images[0].bytes()).toEqual(Uint8Array.from([1, 2, 3]))
+      // MiniMax documents that output URLs expire after 24 hours; the test clock starts at 0.
+      expect(response.images[1].source).toEqual({
+        type: "url",
+        url: "https://cdn.minimax.test/b.jpeg",
+        expiresAt: 24 * 60 * 60 * 1000,
+      })
+      expect(response.providerMetadata).toEqual({ minimax: { id: "trace-1", successCount: 2, failedCount: 0 } })
+    }).pipe(
+      Effect.provide(
+        ImageClient.layer.pipe(
+          Layer.provide(
+            dynamicResponse((input) =>
+              Effect.gen(function* () {
+                const request = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
+                expect(request.url).toBe("https://api.minimax.test/v1/image_generation")
+                expect(request.headers.get("authorization")).toBe("Bearer test")
+                expect(request.headers.get("x-default")).toBe("yes")
+                expect(request.headers.get("x-request")).toBe("yes")
+                expect(JSON.parse(input.text)).toEqual({
+                  model: "image-01",
+                  prompt: "A girl stands by the library window",
+                  subject_reference: [{ type: "character", image_file: "https://example.test/face.jpg" }],
+                  n: 2,
+                  aspect_ratio: "16:9",
+                  response_format: "base64",
+                  prompt_optimizer: true,
+                  seed: 7,
+                  configured: true,
+                  future_option: "http",
+                })
+                return input.respond(
+                  JSON.stringify({
+                    id: "trace-1",
+                    data: { image_base64: ["AQID"], image_urls: ["https://cdn.minimax.test/b.jpeg"] },
+                    metadata: { success_count: 2, failed_count: 0 },
+                    base_resp: { status_code: 0, status_msg: "success" },
+                  }),
+                  { headers: { "content-type": "application/json" } },
+                )
+              }),
+            ),
+          ),
+        ),
+      ),
+    ),
+  )
+
+  it.effect("asks for base64 by default and keeps an explicit url format", () =>
+    Effect.gen(function* () {
+      expect(yield* sent({})).toEqual({ model: "image-01", prompt: "test", response_format: "base64" })
+      expect(yield* sent({ providerOptions: { responseFormat: "url" } })).toMatchObject({ response_format: "url" })
+    }),
+  )
+
+  it.effect("sends inline subject references as data URLs", () =>
+    Effect.gen(function* () {
+      expect(yield* sent({ images: [Media.bytes(Uint8Array.from([1, 2, 3]), "image/png")] })).toMatchObject({
+        subject_reference: [{ type: "character", image_file: "data:image/png;base64,AQID" }],
+      })
+    }),
+  )
+
+  it.effect("uses aspect_ratio presets for about 1K and width and height otherwise", () =>
+    Effect.gen(function* () {
+      const cases = [
+        [{}, {}],
+        [{ aspect: "16:9" }, { aspect_ratio: "16:9" }],
+        [{ aspect: "21:9", resolution: "1K" }, { aspect_ratio: "21:9" }],
+        [{ resolution: "1K" }, { aspect_ratio: "1:1" }],
+        [
+          { aspect: "16:9", resolution: "2K" },
+          { width: 2048, height: 1152 },
+        ],
+        [{ resolution: "2K" }, { width: 2048, height: 2048 }],
+        [{ aspect: "5:4" }, { width: 1144, height: 912 }],
+      ] as const
+      yield* Effect.forEach(cases, ([request, expected]) =>
+        sent(request).pipe(
+          Effect.tap((body) =>
+            Effect.sync(() => {
+              const sizing = Object.fromEntries(
+                Object.entries(body as Record<string, unknown>).filter(([key]) =>
+                  ["aspect_ratio", "width", "height"].includes(key),
+                ),
+              )
+              expect(sizing).toEqual(expected)
+            }),
+          ),
+        ),
+      )
+    }),
+  )
+
+  it.effect("fails with the closest size when MiniMax can't honor the shape", () =>
+    Effect.gen(function* () {
+      const tooLarge = yield* failure({ aspect: "16:9", resolution: "4K" })
+      expect(tooLarge.reason._tag).toBe("UnsupportedOperation")
+      expect(tooLarge.message).toContain("closest size it takes is 2048x1152 (16:9)")
+
+      const live = yield* failure({ aspect: "5:4" }, "image-01-live")
+      expect(live.reason._tag).toBe("UnsupportedOperation")
+      expect(live.message).toContain("image-01-live can't render 5:4; the closest size it takes is 1152x864 (4:3)")
+
+      const liveWide = yield* failure({ aspect: "21:9" }, "image-01-live")
+      expect(liveWide.message).toContain("the closest size it takes is 1280x720 (16:9)")
+
+      const liveLarge = yield* failure({ aspect: "16:9", resolution: "2K" }, "image-01-live")
+      expect(liveLarge.message).toContain("the closest size it takes is 1280x720 (16:9)")
+    }),
+  )
+
+  it.effect("keeps presets on image-01-live", () =>
+    Effect.gen(function* () {
+      expect(yield* sent({ aspect: "9:16" }, "image-01-live")).toMatchObject({ aspect_ratio: "9:16" })
+    }),
+  )
+
+  it.effect("rejects requests MiniMax can't take", () =>
+    Effect.gen(function* () {
+      const images = yield* failure({
+        images: [Media.url("https://example.test/a.jpg"), Media.url("https://example.test/b.jpg")],
+      })
+      expect(images.reason._tag).toBe("UnsupportedOperation")
+
+      const both = yield* failure({ aspect: "16:9", providerOptions: { width: 1024, height: 512 } })
+      expect(both.reason._tag).toBe("InvalidRequest")
+
+      expect(yield* sent({ providerOptions: { width: 1024, height: 512 } })).toMatchObject({ width: 1024, height: 512 })
+    }),
+  )
+
+  it.effect("maps MiniMax status codes", () =>
+    Effect.gen(function* () {
+      const cases = [
+        [1002, "RateLimit"],
+        [1004, "Authentication"],
+        [1008, "QuotaExceeded"],
+        [1026, "ContentPolicy"],
+        [2013, "InvalidRequest"],
+        [9999, "ProviderInternal"],
+      ] as const
+      yield* Effect.forEach(cases, ([code, tag]) =>
+        failure(
+          {},
+          "image-01",
+          JSON.stringify({ data: null, base_resp: { status_code: code, status_msg: "message" } }),
+        ).pipe(Effect.tap((error) => Effect.sync(() => expect(error.reason._tag).toBe(tag)))),
+      )
+
+      const blocked = yield* failure(
+        {},
+        "image-01",
+        JSON.stringify({
+          data: { image_urls: [] },
+          metadata: { success_count: "0", failed_count: "1" },
+          base_resp: { status_code: 0, status_msg: "success" },
+        }),
+      )
+      expect(blocked.reason._tag).toBe("ContentPolicy")
+
+      const empty = yield* failure({}, "image-01", JSON.stringify({ data: {}, base_resp: { status_code: 0 } }))
+      expect(empty.reason._tag).toBe("InvalidProviderOutput")
+    }),
+  )
+})
diff --git a/packages/core/src/provider.ts b/packages/core/src/provider.ts
index 5eb8b3cab5c0..b2b454e3a903 100644
--- a/packages/core/src/provider.ts
+++ b/packages/core/src/provider.ts
@@ -118,6 +118,7 @@ const builtins = new Map<string, () => Promise<unknown>>([
   ["@opencode/ai/providers/meta/responses", () => import("@opencode/ai/providers/meta/responses")],
   ["@opencode/ai/providers/minimax", () => import("@opencode/ai/providers/minimax")],
   ["@opencode/ai/providers/minimax/chat", () => import("@opencode/ai/providers/minimax/chat")],
+  ["@opencode/ai/providers/minimax/images", () => import("@opencode/ai/providers/minimax/images")],
   ["@opencode/ai/providers/minimax/messages", () => import("@opencode/ai/providers/minimax/messages")],
   ["@opencode/ai/providers/minimax/responses", () => import("@opencode/ai/providers/minimax/responses")],
   ["@opencode/ai/providers/mistral", () => import("@opencode/ai/providers/mistral")],