Moonshot AI Provider

The Moonshot AI provider offers access to powerful language models through the Moonshot API, including the Kimi series of models with reasoning capabilities.

API keys can be obtained from the Kimi API Platform.

Setup

The Moonshot AI provider is available via the @ai-sdk/moonshotai module. You can install it with:

pnpm add @ai-sdk/moonshotai

Provider Instance

You can import the default provider instance moonshotai from @ai-sdk/moonshotai:

1
import { moonshotai } from '@ai-sdk/moonshotai';

For custom configuration, you can import createMoonshotAI and create a provider instance with your settings:

1
import { createMoonshotAI } from '@ai-sdk/moonshotai';
2

3
const moonshotai = createMoonshotAI({
4
  apiKey: process.env.MOONSHOT_API_KEY ?? '',
5
});

You can use the following optional settings to customize the Moonshot AI provider instance:

• baseURL string

  Use a different URL prefix for API calls. The default prefix is https://api.moonshot.ai/v1

• apiKey string

  API key that is being sent using the Authorization header. It defaults to the MOONSHOT_API_KEY environment variable

• headers Record<string,string>

  Custom headers to include in the requests

• fetch (input: RequestInfo, init?: RequestInit) => Promise<Response>

  Custom fetch implementation

Language Models

You can create language models using a provider instance:

1
import { moonshotai } from '@ai-sdk/moonshotai';
2
import { generateText } from 'ai';
3

4
const { text } = await generateText({
5
  model: moonshotai('kimi-k3'),
6
  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
7
});

You can also use the .chatModel() or .languageModel() factory methods:

1
const model = moonshotai.chatModel('kimi-k3');
2
// or
3
const model = moonshotai.languageModel('kimi-k3');

Moonshot AI language models can be used in the streamText function (see AI SDK Core).

Moonshot V1 models support the standard temperature, topP, presencePenalty, and frequencyPenalty settings. Kimi models use fixed sampling parameters; the provider omits those settings for Kimi requests and returns an unsupported-setting warning when they are supplied.

Kimi K3 supports toolChoice: 'required'. Kimi K2.6 and the Kimi K2.7 Code models reject that setting, so the provider omits it and returns an unsupported-setting warning for those model IDs. Other tool choice modes are passed through unchanged.

Log Probabilities

Moonshot V1 models can return token log probabilities through provider options. Set logprobs to true, or set topLogprobs to automatically enable log probabilities and request up to 20 alternatives per token:

1
import { moonshotai, type MoonshotAIProviderOptions } from '@ai-sdk/moonshotai';
2
import { generateText } from 'ai';
3

4
const result = await generateText({
5
  model: moonshotai('moonshot-v1-8k'),
6
  prompt: 'Reply with one word that means happy.',
7
  providerOptions: {
8
    moonshotai: {
9
      topLogprobs: 3,
10
    } satisfies MoonshotAIProviderOptions,
11
  },
12
});
13

14
console.log(result.providerMetadata?.moonshotai.logprobs);

The complete content logprob objects are available in Moonshot provider metadata for both generated and streamed responses.

Structured Outputs

Native structured outputs are enabled for Kimi K models and the official Moonshot V1 text, auto, and vision models.

The provider normalizes schemas to Moonshot's supported JSON Schema subset and enables strict schema validation by default.

For unknown custom model IDs, object generation falls back to JSON mode instead of schema-constrained decoding.

For best reliability, include your schema requirements in the prompt in addition to passing the schema to generateObject.

Message Names

Moonshot AI supports optional participant names on system, user, and assistant messages. Set providerOptions.moonshotai.name on each message that should include a name:

1
import {
2
  moonshotai,
3
  type MoonshotAIMessageProviderOptions,
4
} from '@ai-sdk/moonshotai';
5
import { generateText } from 'ai';
6

7
const { text } = await generateText({
8
  model: moonshotai('kimi-k3'),
9
  messages: [
10
    {
11
      role: 'user',
12
      content: 'Suggest a name for my neighborhood book club.',
13
      providerOptions: {
14
        moonshotai: {
15
          name: 'organizer',
16
        } satisfies MoonshotAIMessageProviderOptions,
17
      },
18
    },
19
  ],
20
});

The same option works with streamText. Names are omitted when unset. The provider ignores a name on a tool message and returns a warning. Avoid including unnecessary personal or identifying information in message names.

Partial Mode

Moonshot AI Partial Mode continues a prefix supplied as the final assistant message. Set providerOptions.moonshotai.partial to true on that message:

1
import {
2
  moonshotai,
3
  type MoonshotAIAssistantMessageProviderOptions,
4
} from '@ai-sdk/moonshotai';
5
import { generateText } from 'ai';
6

7
const { text } = await generateText({
8
  model: moonshotai('kimi-k3'),
9
  messages: [
10
    {
11
      role: 'user',
12
      content: 'Complete this sentence about the night sky.',
13
    },
14
    {
15
      role: 'assistant',
16
      content: 'The stars above the city',
17
      providerOptions: {
18
        moonshotai: {
19
          partial: true,
20
        } satisfies MoonshotAIAssistantMessageProviderOptions,
21
      },
22
    },
23
  ],
24
});

The partial assistant message must be the final prompt message. Partial Mode cannot be combined with JSON object response format; JSON schema response format is supported.

Kimi K3 Dynamic Tool Loading

Kimi K3 can load complete function tool definitions at arbitrary positions in a conversation. Add tools to the Moonshot provider options of an empty system message. The provider sends { role: 'system', tools: [...] } without a content field and normalizes each input schema to Moonshot Flavored JSON Schema.

1
import {
2
  moonshotai,
3
  type MoonshotAISystemMessageProviderOptions,
4
} from '@ai-sdk/moonshotai';
5
import { generateText } from 'ai';
6

7
const result = await generateText({
8
  model: moonshotai('kimi-k3'),
9
  allowSystemInMessages: true,
10
  messages: [
11
    { role: 'user', content: 'Help me prepare for a trip.' },
12
    { role: 'assistant', content: 'I can help with that.' },
13
    {
14
      role: 'system',
15
      content: '',
16
      providerOptions: {
17
        moonshotai: {
18
          tools: [
19
            {
20
              type: 'function',
21
              name: 'get_weather',
22
              description: 'Get the current weather for a city',
23
              inputSchema: {
24
                type: 'object',
25
                properties: { city: { type: 'string' } },
26
                required: ['city'],
27
                additionalProperties: false,
28
              },
29
              strict: true,
30
            },
31
          ],
32
        } satisfies MoonshotAISystemMessageProviderOptions,
33
      },
34
    },
35
    { role: 'user', content: 'What is the weather in San Francisco?' },
36
  ],
37
});

Each entry must include its complete function definition. Top-level tools and dynamically loaded tools can be used in the same request. Known unsupported official models omit the dynamic message and return a warning; custom model IDs retain it for forward compatibility.

Reasoning Models

Kimi K3 always reasons and supports low, high, and max reasoning effort. The default is max. You can configure the effort through provider options:

1
import { moonshotai, type MoonshotAIProviderOptions } from '@ai-sdk/moonshotai';
2
import { generateText } from 'ai';
3

4
const { text, reasoningText } = await generateText({
5
  model: moonshotai('kimi-k3'),
6
  providerOptions: {
7
    moonshotai: {
8
      reasoningEffort: 'high',
9
    } satisfies MoonshotAIProviderOptions,
10
  },
11
  prompt: 'How many "r"s are in the word "strawberry"?',
12
});
13

14
console.log(reasoningText);
15
console.log(text);

Kimi K2.5 and K2.6 can enable or disable thinking. Kimi K2.7 always has thinking and preserved reasoning enabled. Keep reasoning history in multi-turn Kimi K2.7 conversations. The reasoning output is exposed through the standard AI SDK reasoning parts.

1
import { moonshotai, type MoonshotAIProviderOptions } from '@ai-sdk/moonshotai';
2
import { streamText } from 'ai';
3

4
const result = streamText({
5
  model: moonshotai('kimi-k2.7-code'),
6
  providerOptions: {
7
    moonshotai: {
8
      thinking: { type: 'enabled' },
9
      reasoningHistory: 'preserved',
10
    } satisfies MoonshotAIProviderOptions,
11
  },
12
  prompt: 'How many "r"s are in the word "strawberry"?',
13
});
14

15
for await (const part of result.fullStream) {
16
  if (part.type === 'reasoning-delta') {
17
    process.stdout.write(part.text);
18
  } else if (part.type === 'text-delta') {
19
    process.stdout.write(part.text);
20
  }
21
}

See AI SDK UI: Chatbot for more details on how to integrate reasoning into your chatbot.

Predicted Outputs

You can provide static predicted content when much of the expected response is already known. Moonshot AI can use the prediction to accelerate the response while still generating any changed content:

1
import { moonshotai, type MoonshotAIProviderOptions } from '@ai-sdk/moonshotai';
2
import { streamText } from 'ai';
3

4
const source = `export function greet(name: string) {
5
  return \`Hello, \${name}!\`;
6
}`;
7

8
const result = streamText({
9
  model: moonshotai('kimi-k3'),
10
  messages: [
11
    {
12
      role: 'user',
13
      content:
14
        'Change the function to say "Welcome" instead of "Hello". Respond only with the updated code.',
15
    },
16
    { role: 'user', content: source },
17
  ],
18
  providerOptions: {
19
    moonshotai: {
20
      prediction: {
21
        type: 'content',
22
        content: source,
23
      },
24
    } satisfies MoonshotAIProviderOptions,
25
  },
26
});
27

28
for await (const textPart of result.textStream) {
29
  process.stdout.write(textPart);
30
}

The content can also be an array of text parts:

1
prediction: {
2
  type: 'content',
3
  content: [
4
    { type: 'text', text: 'First known section' },
5
    { type: 'text', text: 'Second known section' },
6
  ],
7
}

Provider Options

The following optional provider options are available for Moonshot AI language models:

• strictJsonSchema boolean

  Whether to use strict JSON schema validation for structured outputs. Defaults to true.

• logprobs boolean

  Whether to return log probabilities for generated tokens.

• topLogprobs number

  Number of most likely tokens to return at each token position, from 0 to 20. Setting this option automatically enables logprobs.

• reasoningEffort 'low' | 'high' | 'max'

  Reasoning effort for Kimi K3. Defaults to 'max'.

• prediction { type: 'content'; content: string | Array<{ type: 'text'; text: string }> }

  Supplies static predicted output that can accelerate requests where most of the response is already known.

• thinking object

  Configuration for Kimi K2.5 and K2.6. Kimi K2.7 accepts only enabled because its thinking cannot be disabled. Kimi K3 does not accept this field.

  • type 'enabled' | 'disabled'

    Whether to enable thinking mode. For Kimi K2.7 Code, only 'enabled' is accepted.

  • budgetTokens number

    Deprecated. Moonshot Chat Completions does not support thinking budgets. The provider omits this value and returns a warning. It remains accepted for backwards compatibility.

• reasoningHistory 'disabled' | 'interleaved' | 'preserved'

  Controls preserved reasoning behavior in multi-turn conversations:

  • 'disabled' and 'interleaved' are retained for compatibility. They do not change the request, so the model's server-default behavior applies.
  • 'preserved' maps to thinking.keep: 'all' for Kimi K2.6. Kimi K2.7 and K3 preserve reasoning by default.

Chat Response Metadata

Moonshot AI preserves provider-specific response fields in providerMetadata.moonshotai for generated and streamed responses:

• responseObject: chat.completion or chat.completion.chunk
• choiceIndex: the selected response choice index
• messageRole: the response message role, when supplied
• toolCallTypes: the tool-call type for each returned call

These fields remain in provider metadata because they are specific to Moonshot AI's Chat Completions response rather than shared AI SDK result fields.

Model Capabilities

The Moonshot V1 series and Kimi K2.5 are unavailable to newly registered users and are scheduled for full platform sunset on August 31, 2026. They remain listed because they are still part of the Chat Completions API model surface, but new applications should use Kimi K3, Kimi K2.7 Code, or Kimi K2.6.