Kimi Provider

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

string

Your Kimi (Moonshot AI) API key.

string

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

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

Provider support

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

Model capabilities

Inspect model.capabilities before setting reasoning, sampling, or tool-choice options:

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

For both registered K2.7 Code models:

reasoning.mode is always-on; thinking cannot be disabled.
supportedEfforts is empty because Kimi does not accept effort control.
restrictsSamplingParams is true; do not pass temperature or topP.
supportedToolChoices is ['auto', 'none'].
modalities.input / modalities.output are both ['text']; both are text-only models.

An empty effort list does not mean reasoning output is unavailable. It means the model chooses its own reasoning effort.

Strict tool schemas

Kimi models report model.capabilities.tools.strictSchemas as { supported: true }. Tools with strict: true are forwarded per tool with strict: true and a normalized schema; other tools are sent unchanged. The endpoint rejects strict tools it cannot enforce. See Strict tool schemas for the schema contract and error reasons. This tool behavior is separate from structured output. generateObject() and streamObject() use JSON Mode and then validate the returned object against your schema when it is a Standard Schema.

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' }). JSON Mode does not enforce the schema, so core-ai validates the returned JSON when your schema is a Standard Schema, such as a Zod 4.2+ schema. With plain JSON Schema, validate result.object yourself.

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);

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,
            stopSequences: ['END'],
            seed: 42,
        },
    },
});

Available fields: parallelToolCalls, 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

Core

Providers

Overview

Installation

createKimi()

Options

Returns

Supported models

Provider support

Model capabilities

Strict tool schemas

Examples

Basic chat

Streaming

Multi-turn reasoning preservation

Fixed sampling constraints

Structured output

Provider-specific options

Error handling

OpenAI Compat Provider

core-ai Functions

​Overview

​Installation

​createKimi()

​Options

​Returns

​Supported models

​Provider support

​Model capabilities

​Strict tool schemas

​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

Provider support

Model capabilities

Strict tool schemas

Examples

Basic chat

Streaming

Multi-turn reasoning preservation

Fixed sampling constraints

Structured output

Provider-specific options

Error handling

Related