feat: minimax provider

Author: qinjiu

content/providers/01-ai-sdk-providers/35-minimax.mdx

@@ -0,0 +1,264 @@
+---
+title: MiniMax
+description: Learn how to use MiniMax's models with the AI SDK.
+---
+
+# MiniMax Provider
+
+The [MiniMax](https://www.minimaxi.com) provider offers access to powerful language models through the MiniMax API, including their latest [MiniMax-M2 model](https://platform.minimaxi.com/docs/guides/text-generation).
+
+API keys can be obtained from the [MiniMax Platform](https://platform.minimaxi.com).
+
+## Setup
+
+The MiniMax provider is available via the `@ai-sdk/minimax` module. You can install it with:
+
+<Tabs items={['pnpm', 'npm', 'yarn', 'bun']}>
+  <Tab>
+    <Snippet text="pnpm add @ai-sdk/minimax" dark />
+  </Tab>
+  <Tab>
+    <Snippet text="npm install @ai-sdk/minimax" dark />
+  </Tab>
+  <Tab>
+    <Snippet text="yarn add @ai-sdk/minimax" dark />
+  </Tab>
+
+  <Tab>
+    <Snippet text="bun add @ai-sdk/minimax" dark />
+  </Tab>
+</Tabs>
+
+## Provider Instance
+
+The MiniMax provider supports two API compatibility modes:
+
+### OpenAI-Compatible API (Default)
+
+You can import the default provider instance `minimax` from `@ai-sdk/minimax`:
+
+```ts
+import { minimax } from '@ai-sdk/minimax';
+```
+
+Or explicitly use the OpenAI-compatible instance:
+
+```ts
+import { minimaxOpenAI } from '@ai-sdk/minimax';
+```
+
+### Anthropic-Compatible API
+
+For Anthropic-compatible API format:
+
+```ts
+import { minimaxAnthropic } from '@ai-sdk/minimax';
+```
+
+## Custom Configuration
+
+For custom configuration, you can use the `createMinimax` or `createMinimaxAnthropic` functions:
+
+### OpenAI-Compatible Configuration
+
+```ts
+import { createMinimax } from '@ai-sdk/minimax';
+
+const minimax = createMinimax({
+  apiKey: process.env.MINIMAX_API_KEY ?? '',
+  baseURL: 'https://api.minimaxi.com/v1', // optional, this is the default
+});
+```
+
+### Anthropic-Compatible Configuration
+
+```ts
+import { createMinimaxAnthropic } from '@ai-sdk/minimax';
+
+const minimaxAnthropic = createMinimaxAnthropic({
+  apiKey: process.env.MINIMAX_API_KEY ?? '',
+  baseURL: 'https://api.minimaxi.com/anthropic', // optional, this is the default
+});
+```
+
+### Configuration Options
+
+You can use the following optional settings to customize the MiniMax provider instance:
+
+- **baseURL** _string_
+
+  Use a different URL prefix for API calls.
+  - OpenAI-compatible default: `https://api.minimaxi.com/v1`
+  - Anthropic-compatible default: `https://api.minimaxi.com/anthropic`
+
+- **apiKey** _string_
+
+  API key that is being sent using the `Authorization` header. It defaults to
+  the `MINIMAX_API_KEY` environment variable.
+
+- **headers** _Record&lt;string,string&gt;_
+
+  Custom headers to include in the requests.
+
+- **fetch** _(input: RequestInfo, init?: RequestInit) => Promise&lt;Response&gt;_
+
+  Custom [fetch](https://developer.mozilla.org/en-US/docs/Web/API/fetch) implementation.
+
+## Language Models
+
+You can create language models using a provider instance:
+
+### OpenAI-Compatible
+
+```ts
+import { minimax } from '@ai-sdk/minimax';
+import { generateText } from 'ai';
+
+const { text } = await generateText({
+  model: minimax('MiniMax-M2'),
+  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
+});
+```
+
+### Anthropic-Compatible
+
+```ts
+import { minimaxAnthropic } from '@ai-sdk/minimax';
+import { generateText } from 'ai';
+
+const { text } = await generateText({
+  model: minimaxAnthropic('MiniMax-M2'),
+  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
+});
+```
+
+You can also use the `.chat()` or `.languageModel()` factory methods:
+
+```ts
+const model = minimax.chat('MiniMax-M2');
+// or
+const model = minimax.languageModel('MiniMax-M2');
+
+// For Anthropic-compatible:
+const anthropicModel = minimaxAnthropic.chat('MiniMax-M2');
+// or
+const anthropicModel = minimaxAnthropic.languageModel('MiniMax-M2');
+```
+
+MiniMax language models can be used in the `streamText` function
+(see [AI SDK Core](/docs/ai-sdk-core)).
+
+## API Compatibility
+
+MiniMax provides two API formats. Both are included in this package:
+
+### When to Use Each Format
+
+- **OpenAI-Compatible** (`minimax`): Use this as your default. It's simpler and works well for most use cases.
+- **Anthropic-Compatible** (`minimaxAnthropic`): Use this if you need specific Anthropic features or are migrating from Anthropic.
+
+### Key Differences
+
+The main difference is the API request/response format:
+
+- **OpenAI format**: Uses standard OpenAI chat completion format
+- **Anthropic format**: Uses Anthropic Messages API format (requires `anthropic-version` header)
+
+Both formats access the same MiniMax models with the same capabilities.
+
+## Model Capabilities
+
+| Model         | Text Generation     | Object Generation   | Image Input         | Tool Usage          | Tool Streaming      |
+| ------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- |
+| `MiniMax-M2`  | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
+
+<Note>
+  Please see the [MiniMax docs](https://platform.minimaxi.com/docs) for a full list
+  of available models and their capabilities. The provider accepts any model ID as a
+  string for forward compatibility.
+</Note>
+
+## Example Usage
+
+### Basic Text Generation
+
+```ts
+import { minimax } from '@ai-sdk/minimax';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: minimax('MiniMax-M2'),
+  prompt: 'Explain quantum computing in simple terms.',
+});
+
+console.log(result.text);
+```
+
+### Streaming
+
+```ts
+import { minimax } from '@ai-sdk/minimax';
+import { streamText } from 'ai';
+
+const result = streamText({
+  model: minimax('MiniMax-M2'),
+  prompt: 'Write a short story about a robot learning to paint.',
+});
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+### With Tools
+
+```ts
+import { minimax } from '@ai-sdk/minimax';
+import { generateText } from 'ai';
+import { z } from 'zod';
+
+const result = await generateText({
+  model: minimax('MiniMax-M2'),
+  tools: {
+    weather: {
+      description: 'Get the weather in a location',
+      parameters: z.object({
+        location: z.string().describe('The location to get the weather for'),
+      }),
+      execute: async ({ location }) => ({
+        location,
+        temperature: 72 + Math.floor(Math.random() * 21) - 10,
+      }),
+    },
+  },
+  prompt: 'What is the weather in San Francisco?',
+});
+
+console.log(result.text);
+```
+
+### With Image Input
+
+```ts
+import { minimax } from '@ai-sdk/minimax';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: minimax('MiniMax-M2'),
+  messages: [
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'What is in this image?' },
+        {
+          type: 'image',
+          image: 'https://example.com/image.jpg',
+        },
+      ],
+    },
+  ],
+});
+
+console.log(result.text);
+```
+

packages/minimax/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['vercel-ai'],
+};
+

packages/minimax/.gitignore

@@ -0,0 +1,9 @@
+dist
+node_modules
+*.tsbuildinfo
+.turbo
+.env
+.env.local
+.DS_Store
+coverage
+*.log

packages/minimax/.npmignore

@@ -0,0 +1,26 @@
+src
+*.test.ts
+*.test.tsx
+__tests__
+__mocks__
+__fixtures__
+__snapshots__
+tsconfig.json
+tsconfig.build.json
+tsup.config.ts
+vitest.*.config.js
+turbo.json
+.eslintrc.js
+.gitignore
+.env
+.env.*
+*.tsbuildinfo
+.turbo
+coverage
+*.log
+
+# Documentation that should not be in the package
+INSTALLATION.md
+PROJECT_OVERVIEW.md
+COMMUNITY_PROVIDER_SUBMISSION.md
+SUMMARY.md

packages/minimax/.prettierrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ...require('../../.prettierrc.js'),
+};
+

packages/minimax/CHANGELOG.md

@@ -0,0 +1,16 @@
+# @ai-sdk/minimax
+
+## 0.0.1
+
+### Initial Release
+
+- Added MiniMax provider with support for MiniMax-M2 text generation model
+- **Default provider**: Anthropic-compatible API via `minimax` and `createMinimax` exports
+- OpenAI-compatible API interface via `minimaxOpenAI` and `createMinimaxOpenAI` exports  
+- Anthropic-compatible API interface via `minimaxAnthropic` export
+- Both compatibility modes included in a single package
+- Streaming and non-streaming text generation
+- Custom configuration support for both modes
+- Separate test files for each provider for better maintainability
+- Provider identifiers: `minimax.anthropic` and `minimax.openai`
+