Kimi Provider - core-ai

Overview

The Kimi provider connects to the Moonshot AI Kimi API — an OpenAI-compatible Chat Completions endpoint. Use your Kimi API key and supported model IDs such as kimi-k2.7-code.

Installation

npm install @core-ai/kimi

createKimi()

Create a Kimi provider instance.

import { createKimi } from '@core-ai/kimi';

const kimi = createKimi({
  apiKey: process.env.KIMI_API_KEY,
});

Options

apiKey

string

Your Kimi (Moonshot AI) API key.

baseURL

string

Custom API base URL. Defaults to https://api.moonshot.ai/v1.

client

OpenAI

Provide your own configured OpenAI SDK client instance.

Returns

KimiProvider with method chatModel().

Supported models

kimi-k2.7-code — coding-focused agentic model with always-on thinking and preserved reasoning
kimi-k2.7-code-highspeed — same model with higher output speed

Capabilities

Feature	Support
Chat Completion	Yes
Streaming	Yes
Function Calling	Yes
Vision	Yes
Reasoning	Yes (always on for K2.7 Code)
Structured Output (`generateObject` / `streamObject`)	Yes (JSON Mode with client-side schema validation)
Embeddings	No
Image Generation	No

Examples

Basic chat

import { createKimi } from '@core-ai/kimi';
import { generate } from '@core-ai/core-ai';

const kimi = createKimi({
  apiKey: process.env.KIMI_API_KEY,
});

const model = kimi.chatModel('kimi-k2.7-code');

const result = await generate({
  model,
  messages: [{ role: 'user', content: 'Implement quicksort in TypeScript.' }],
  maxTokens: 32768,
});

console.log(result.content);

Streaming

import { createKimi } from '@core-ai/kimi';
import { stream } from '@core-ai/core-ai';

const kimi = createKimi({
  apiKey: process.env.KIMI_API_KEY,
});

const model = kimi.chatModel('kimi-k2.7-code');

const chatStream = await stream({
  model,
  messages: [{ role: 'user', content: 'Explain dependency injection.' }],
});

for await (const event of chatStream) {
  if (event.type === 'reasoning-delta') {
    process.stdout.write(event.text);
  }
  if (event.type === 'text-delta') {
    process.stdout.write(event.text);
  }
}

Multi-turn reasoning preservation

Kimi K2.7 Code requires historical reasoning_content in assistant messages. core-ai preserves this automatically when you use resultToMessage():

import { createKimi } from '@core-ai/kimi';
import { generate, resultToMessage } from '@core-ai/core-ai';

const kimi = createKimi({ apiKey: process.env.KIMI_API_KEY });
const model = kimi.chatModel('kimi-k2.7-code');

const messages = [{ role: 'user', content: 'Plan a refactor.' }];
const firstResult = await generate({ model, messages, maxTokens: 32768 });

const followUp = await generate({
  model,
  messages: [
    ...messages,
    resultToMessage(firstResult),
    { role: 'user', content: 'Now implement step one.' },
  ],
  maxTokens: 32768,
});

Fixed sampling constraints

For kimi-k2.7-code and kimi-k2.7-code-highspeed, Moonshot fixes sampling parameters server-side:

temperature: 1.0
top_p: 0.95
penalties: 0.0

Do not pass custom temperature or topP values. The provider validates these locally and omits fixed parameters from outbound requests.

Kimi K2.7 Code always runs in thinking mode. Thinking cannot be disabled for this model family.

Structured output

generateObject() and streamObject() use Moonshot JSON Mode (response_format: { type: 'json_object' }) and validate the returned JSON with your Zod schema.

import { createKimi } from '@core-ai/kimi';
import { generateObject } from '@core-ai/core-ai';
import { z } from 'zod';

const kimi = createKimi({ apiKey: process.env.KIMI_API_KEY });
const model = kimi.chatModel('kimi-k2.7-code');

const result = await generateObject({
  model,
  messages: [{ role: 'user', content: 'Return the weather for Berlin.' }],
  schema: z.object({
    city: z.string(),
    temperatureC: z.number(),
  }),
  schemaName: 'weather_schema',
});

console.log(result.object);

You can also use JSON Mode directly with generate():

import { createKimi } from '@core-ai/kimi';
import { generate } from '@core-ai/core-ai';
import { z } from 'zod';

const kimi = createKimi({ apiKey: process.env.KIMI_API_KEY });
const model = kimi.chatModel('kimi-k2.7-code');

const schema = z.object({ city: z.string(), temperatureC: z.number() });

const result = await generate({
  model,
  messages: [
    {
      role: 'user',
      content:
        'Return only valid JSON matching {"city": string, "temperatureC": number}.',
    },
  ],
  providerOptions: {
    kimi: {
      responseFormat: { type: 'json_object' },
    },
  },
});

const object = schema.parse(JSON.parse(result.content ?? '{}'));

Forced tool choice via toolChoice: { type: 'tool', toolName } is rejected on K2.7 Code models because Moonshot does not allow forced tool selection while thinking is always enabled.

Provider-specific options

Pass Kimi-specific options via providerOptions.kimi:

await generate({
  model: kimi.chatModel('kimi-k2.7-code'),
  messages: [{ role: 'user', content: 'Hello!' }],
  providerOptions: {
    kimi: {
      parallelToolCalls: true,
      responseFormat: { type: 'json_object' },
      stopSequences: ['END'],
      seed: 42,
    },
  },
});

Available fields: parallelToolCalls, responseFormat, stopSequences, seed, user.

Error handling

import { ProviderError } from '@core-ai/core-ai';

try {
  const result = await generate({
    model: kimi.chatModel('kimi-k2.7-code'),
    messages: [{ role: 'user', content: 'Hello!' }],
  });
} catch (error) {
  if (error instanceof ProviderError) {
    console.error('Kimi API error:', error.message);
    console.error('Status:', error.statusCode);
  }
}

OpenAI Compat Provider

OpenAI Chat Completions compatibility reference

core-ai Functions

Learn about generate, stream, and more

​Overview

​Installation

​createKimi()

​Options

​Returns

​Supported models

​Capabilities

​Examples

​Basic chat

​Streaming

​Multi-turn reasoning preservation

​Fixed sampling constraints

​Structured output

​Provider-specific options

​Error handling

​Related

OpenAI Compat Provider

core-ai Functions

Overview

Installation

createKimi()

Options

Returns

Supported models

Capabilities

Examples

Basic chat

Streaming

Multi-turn reasoning preservation

Fixed sampling constraints

Structured output

Provider-specific options

Error handling

Related