@arnilo/prism-provider-kimi 0.0.5 → 0.0.6

package/CHANGELOG.md

@@ -5,7 +5,9 @@ All notable changes to @arnilo/prism-provider-kimi will be documented in this fi
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.0.6] - 2026-07-19
+
+- Released with the exact 0.0.6 first-party package graph.
 
 ## [0.0.5] - 2026-07-16
 

package/README.md

@@ -1,28 +1,48 @@
 # @arnilo/prism-provider-kimi
 
-Kimi provider package for Prism.
+Kimi For Coding (Anthropic `/messages`) + optional Moonshot Open Platform (Chat Completions) for Prism.
 
 ```ts
-import { createKimiProviderPackage } from "@arnilo/prism-provider-kimi";
+import { createKimiProviderPackage, listKimiModels } from "@arnilo/prism-provider-kimi";
 
 api.registerProviderPackage(createKimiProviderPackage({ kimiApiKey: "fake-kimi-key" }));
+
+// Opt-in callable Moonshot + featured Open Platform models
+api.registerProviderPackage(createKimiProviderPackage({
+  kimiApiKey: "fake-kimi-key",
+  includeMoonshotModels: true,
+  moonshotApiKey: "fake-moonshot-key",
+}));
+
+// Caller-gated discovery (never during setup)
+const models = await listKimiModels({ apiKey: "fake-moonshot-key" });
 ```
 
 Exports:
 - `createKimiProviderPackage()`
-- `createKimiCodingProvider()`
-- `kimiCodingModels`
-- `moonshotKimiModels`
-- `defineKimiModel()`
+- `createKimiCodingProvider()` / `createMoonshotProvider()`
+- `listKimiModels()` / `mapKimiModel()` / `defineKimiModel()`
+- `kimiCodingModels` / `moonshotKimiModels`
+- `kimiThinking` / `kimiReasoningEffort` / `kimiPreserveThinking`
 
 Security defaults:
 - No network calls during import, setup, build, or default tests.
 - No automatic environment, file, keychain, or shell credential lookup.
-- Kimi credentials are resolved per request from caller-supplied values or resolvers.
-- Moonshot/Open Platform model metadata is registered only with `includeMoonshotModels: true`.
+- Credentials are resolved per request from caller-supplied values or resolvers.
+- Moonshot Open Platform is registered only with `includeMoonshotModels: true`.
+
+Official model ids:
+- Coding featured: `kimi-for-coding`, `kimi-for-coding-highspeed`, `k3` (not Pi `k2p7`).
+- Open Platform featured: `kimi-k2.7-code`, `kimi-k3` (+ `listKimiModels()`).
 
 Cache behavior:
-- Default catalog models use implicit caching (no `cache_control`); opt in via `ModelConfig.cache.kind: "cache_control"` on the Anthropic route.
-- When opted in, `cache_control` markers apply only to selected `cache.breakpoints` (`"long"` → `ttl: "1h"`); Moonshot OpenAI route sends none.
-- `cache_read_input_tokens`/`cache_creation_input_tokens` map to `Usage.cacheReadTokens`/`cacheWriteTokens`.
+- Default Coding models use implicit caching (no `cache_control`); opt in via `ModelConfig.cache.kind: "cache_control"`.
+- When opted in, markers apply only to selected `cache.breakpoints` (`"long"` → `ttl: "1h"`).
+- Moonshot never sends Anthropic `cache_control`.
+- Coding `cache_read_input_tokens`/`cache_creation_input_tokens` map to `Usage.cacheReadTokens`/`cacheWriteTokens`.
 - Provider-owned headers (`content-type`, `user-agent`, `authorization`) win over caller headers.
+
+Thinking:
+- K2.x: `compat.thinking` (`type` / optional `keep`); K2.7-code omits `thinking` by default (always on).
+- K3 / Coding `k3`: `compat.reasoning_effort` (per-turn override wins).
+- Moonshot replays `reasoning_content` when `preserveThinking`.

package/dist/index.d.ts

@@ -1,14 +1,27 @@
 import { type CredentialValueSource, type ModelConfig, type ProviderPackage } from "@arnilo/prism";
 export interface KimiProviderPackageOptions {
     readonly kimiApiKey?: CredentialValueSource;
+    /** Moonshot Open Platform API key (not interchangeable with Kimi Coding keys). */
+    readonly moonshotApiKey?: CredentialValueSource;
     readonly fetch?: typeof fetch;
     readonly baseUrl?: string;
+    /** Moonshot Open Platform base URL (default `https://api.moonshot.ai/v1`). */
+    readonly moonshotBaseUrl?: string;
     readonly id?: string;
+    readonly moonshotId?: string;
     readonly userAgent?: string;
+    /** Overrides featured `kimiCodingModels` registered on the coding provider. */
     readonly models?: readonly ModelConfig[];
+    /**
+     * When true, registers a callable Moonshot Open Platform Chat Completions provider
+     * plus featured/override Moonshot models (`compat.route: "openai"`).
+     */
     readonly includeMoonshotModels?: boolean;
     readonly moonshotModels?: readonly ModelConfig[];
 }
 export declare function createKimiProviderPackage(options?: KimiProviderPackageOptions): ProviderPackage;
-export { defineKimiModel, kimiCodingModels, moonshotKimiModels, type KimiModelConfig } from "./models.js";
-export { createKimiCodingProvider, kimiAnthropicBody, kimiAnthropicEvents, type KimiCodingProviderOptions } from "./provider.js";
+export { defineKimiModel, kimiCodingModels, listKimiModels, mapKimiModel, moonshotKimiModels, type KimiModelConfig, type KimiModelEntry, type ListKimiModelsOptions, } from "./models.js";
+export { createKimiCodingProvider, kimiAnthropicBody, kimiAnthropicEvents, type KimiCodingProviderOptions, } from "./provider.js";
+export { createMoonshotProvider, moonshotBody, moonshotEvents, serializeMoonshotMessage, type MoonshotProviderOptions, } from "./moonshot.js";
+export { kimiPreserveThinking, kimiReasoningEffort, kimiThinking, stripKimiThinkingCompat, } from "./thinking.js";
+export { applyKimiAnthropicCacheControl, kimiAnthropicCacheEnabled, } from "./cache.js";

package/dist/index.js

@@ -1,23 +1,44 @@
 import { defineProviderPackage } from "@arnilo/prism";
 import { kimiCodingModels, moonshotKimiModels } from "./models.js";
+import { createMoonshotProvider } from "./moonshot.js";
 import { createKimiCodingProvider } from "./provider.js";
 export function createKimiProviderPackage(options = {}) {
     const providerId = options.id ?? "kimi-coding";
+    const moonshotId = options.moonshotId ?? "moonshot";
     return defineProviderPackage({
         name: "@arnilo/prism-provider-kimi",
         description: "Kimi provider package for Prism.",
         docs: { links: ["docs/providers/kimi.md"] },
         setup(api) {
-            api.registerProvider(createKimiCodingProvider({ ...options, id: providerId, apiKey: options.kimiApiKey }));
-            for (const model of options.models ?? kimiCodingModels)
+            api.registerProvider(createKimiCodingProvider({
+                id: providerId,
+                apiKey: options.kimiApiKey,
+                fetch: options.fetch,
+                baseUrl: options.baseUrl,
+                userAgent: options.userAgent,
+            }));
+            for (const model of options.models ?? kimiCodingModels) {
                 api.registerModel({ ...model, provider: providerId });
-            if (options.includeMoonshotModels)
-                for (const model of options.moonshotModels ?? moonshotKimiModels)
-                    api.registerModel(model);
+            }
             api.registerAuthMethod({ kind: "api_key", provider: providerId, credentialName: "apiKey" });
+            if (options.includeMoonshotModels) {
+                api.registerProvider(createMoonshotProvider({
+                    id: moonshotId,
+                    apiKey: options.moonshotApiKey ?? options.kimiApiKey,
+                    fetch: options.fetch,
+                    baseUrl: options.moonshotBaseUrl,
+                }));
+                for (const model of options.moonshotModels ?? moonshotKimiModels) {
+                    api.registerModel({ ...model, provider: moonshotId });
+                }
+                api.registerAuthMethod({ kind: "api_key", provider: moonshotId, credentialName: "apiKey" });
+            }
         },
     });
 }
-export { defineKimiModel, kimiCodingModels, moonshotKimiModels } from "./models.js";
-export { createKimiCodingProvider, kimiAnthropicBody, kimiAnthropicEvents } from "./provider.js";
+export { defineKimiModel, kimiCodingModels, listKimiModels, mapKimiModel, moonshotKimiModels, } from "./models.js";
+export { createKimiCodingProvider, kimiAnthropicBody, kimiAnthropicEvents, } from "./provider.js";
+export { createMoonshotProvider, moonshotBody, moonshotEvents, serializeMoonshotMessage, } from "./moonshot.js";
+export { kimiPreserveThinking, kimiReasoningEffort, kimiThinking, stripKimiThinkingCompat, } from "./thinking.js";
+export { applyKimiAnthropicCacheControl, kimiAnthropicCacheEnabled, } from "./cache.js";
 //# sourceMappingURL=index.js.map

package/dist/models.d.ts

@@ -1,11 +1,65 @@
-import type { JsonObject, ModelConfig } from "@arnilo/prism";
+import { type CredentialValueSource, type JsonObject, type ModelConfig } from "@arnilo/prism";
 export interface KimiModelConfig extends Omit<ModelConfig, "provider" | "compat"> {
     readonly provider?: "kimi-coding" | "moonshot";
     readonly compat?: JsonObject & {
         readonly route?: "anthropic" | "openai";
         readonly preserveThinking?: boolean;
+        /** Official K2.x `thinking` object (`type`, optional `keep`). */
+        readonly thinking?: boolean | JsonObject;
+        /** Official K3 `reasoning_effort` (`"max"` on Open Platform; Coding `k3` also `low`/`high`). */
+        readonly reasoning_effort?: string;
     };
 }
+export interface ListKimiModelsOptions {
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    /** Defaults to Open Platform `https://api.moonshot.ai/v1` (also supports `api.moonshot.cn/v1`). */
+    readonly baseUrl?: string;
+    readonly signal?: AbortSignal;
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Defaults to `"moonshot"`. */
+    readonly provider?: "moonshot" | string;
+}
+/**
+ * Official Moonshot / Kimi Open Platform `GET /v1/models` entry.
+ * @see https://platform.kimi.ai/docs/api/list-models
+ */
+export interface KimiModelEntry {
+    readonly id: string;
+    readonly object?: string;
+    readonly created?: number;
+    readonly owned_by?: string;
+    readonly context_length?: number;
+    readonly supports_image_in?: boolean;
+    readonly supports_video_in?: boolean;
+    readonly supports_reasoning?: boolean;
+}
 export declare function defineKimiModel(config: KimiModelConfig): ModelConfig;
-export declare const kimiCodingModels: readonly [ModelConfig];
-export declare const moonshotKimiModels: readonly [ModelConfig];
+/**
+ * Caller-gated Moonshot Open Platform model discovery via official `GET /v1/models`.
+ * Never invoked by `createKimiProviderPackage` — hosts call this and pass results via
+ * `moonshotModels:` / `models:` (or register themselves).
+ * Kimi For Coding (`api.kimi.com/coding`) has no public list API; use featured
+ * `kimiCodingModels` (official Coding ids) as offline bootstrap.
+ * @see https://platform.kimi.ai/docs/api/list-models
+ */
+export declare function listKimiModels(options?: ListKimiModelsOptions): Promise<ModelConfig[]>;
+/**
+ * Map an official Moonshot `/v1/models` entry to Prism `ModelConfig`.
+ * Open Platform models use Chat Completions (`compat.route: "openai"`).
+ */
+export declare function mapKimiModel(entry: KimiModelEntry, options?: {
+    readonly provider?: string;
+}): ModelConfig;
+/**
+ * Featured Kimi For Coding offline bootstrap aliases — official Coding model ids
+ * from https://www.kimi.com/code/docs/en/kimi-code/models (not Pi's `k2p7` alias).
+ * Refresh Open Platform catalogs via `listKimiModels()`.
+ */
+export declare const kimiCodingModels: readonly [ModelConfig, ModelConfig, ModelConfig];
+/**
+ * Featured Moonshot Open Platform offline bootstrap aliases — official Open Platform
+ * ids from https://platform.kimi.ai/docs/models. Callable via `createMoonshotProvider`
+ * when `includeMoonshotModels: true`. Refresh via `listKimiModels()`.
+ */
+export declare const moonshotKimiModels: readonly [ModelConfig, ModelConfig];

package/dist/models.js

@@ -1,23 +1,189 @@
+import { redactSecrets, resolveCredentialValue, } from "@arnilo/prism";
+import { readBoundedResponseText } from "@arnilo/prism/providers/transport";
 export function defineKimiModel(config) {
-    return { ...config, provider: config.provider ?? "kimi-coding", capabilities: { input: ["text"], output: ["text"], reasoning: true, tools: true, streaming: true, ...config.capabilities } };
+    return {
+        ...config,
+        provider: config.provider ?? "kimi-coding",
+        capabilities: {
+            input: ["text"],
+            output: ["text"],
+            reasoning: true,
+            tools: true,
+            streaming: true,
+            ...config.capabilities,
+        },
+    };
 }
+/**
+ * Caller-gated Moonshot Open Platform model discovery via official `GET /v1/models`.
+ * Never invoked by `createKimiProviderPackage` — hosts call this and pass results via
+ * `moonshotModels:` / `models:` (or register themselves).
+ * Kimi For Coding (`api.kimi.com/coding`) has no public list API; use featured
+ * `kimiCodingModels` (official Coding ids) as offline bootstrap.
+ * @see https://platform.kimi.ai/docs/api/list-models
+ */
+export async function listKimiModels(options = {}) {
+    const provider = options.provider ?? "moonshot";
+    const baseUrl = (options.baseUrl ?? "https://api.moonshot.ai/v1").replace(/\/$/, "");
+    const token = await resolveCredentialValue(options.apiKey, { provider, name: "apiKey" });
+    const response = await (options.fetch ?? fetch)(`${baseUrl}/models`, {
+        method: "GET",
+        headers: { ...options.headers, ...(token ? { authorization: `Bearer ${token}` } : {}) },
+        signal: options.signal,
+    });
+    if (!response.ok) {
+        const body = await readBoundedResponseText(response, { secrets: [token] });
+        throw new Error(`Kimi model discovery failed: ${response.status} ${redactSecrets(body, [token])}`);
+    }
+    const payload = (await response.json());
+    if (!Array.isArray(payload.data))
+        throw new Error("Kimi model discovery response missing data array");
+    return payload.data.map((entry) => mapKimiModel(entry, { provider }));
+}
+/**
+ * Map an official Moonshot `/v1/models` entry to Prism `ModelConfig`.
+ * Open Platform models use Chat Completions (`compat.route: "openai"`).
+ */
+export function mapKimiModel(entry, options = {}) {
+    if (!entry || typeof entry.id !== "string" || entry.id.length === 0) {
+        throw new Error("Kimi model entry missing id");
+    }
+    const id = entry.id;
+    const reasoning = entry.supports_reasoning === true || looksLikeReasoningModel(id);
+    const input = entry.supports_image_in ? ["text", "image"] : ["text"];
+    return defineKimiModel({
+        provider: options.provider ?? "moonshot",
+        model: id,
+        displayName: id,
+        capabilities: {
+            input,
+            output: ["text"],
+            reasoning,
+            tools: true,
+            streaming: true,
+        },
+        limits: cleanLimits({
+            contextWindow: typeof entry.context_length === "number" ? entry.context_length : undefined,
+        }),
+        compat: cleanJson({
+            route: "openai",
+            preserveThinking: reasoning && shouldPreserveThinkingByDefault(id),
+            ...thinkingDefaultsForModel(id),
+            moonshot: cleanJson({
+                owned_by: entry.owned_by,
+                created: entry.created,
+                supports_video_in: entry.supports_video_in,
+                supports_reasoning: entry.supports_reasoning,
+            }),
+        }),
+    });
+}
+/**
+ * Featured Kimi For Coding offline bootstrap aliases — official Coding model ids
+ * from https://www.kimi.com/code/docs/en/kimi-code/models (not Pi's `k2p7` alias).
+ * Refresh Open Platform catalogs via `listKimiModels()`.
+ */
 export const kimiCodingModels = [
     defineKimiModel({
         provider: "kimi-coding",
-        model: "kimi-k2.7-code",
-        displayName: "Kimi K2.7 Code",
+        model: "kimi-for-coding",
+        displayName: "Kimi For Coding (K2.7 Code)",
         capabilities: { input: ["text", "document", "file"] },
         limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
-        compat: { route: "anthropic", preserveThinking: true },
+        compat: {
+            route: "anthropic",
+            // Official: thinking always on — omit `thinking` on the wire unless the host sets it.
+            preserveThinking: true,
+        },
+    }),
+    defineKimiModel({
+        provider: "kimi-coding",
+        model: "kimi-for-coding-highspeed",
+        displayName: "Kimi For Coding Highspeed",
+        capabilities: { input: ["text", "document", "file"] },
+        limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
+        compat: {
+            route: "anthropic",
+            preserveThinking: true,
+        },
+    }),
+    defineKimiModel({
+        provider: "kimi-coding",
+        model: "k3",
+        displayName: "Kimi K3 (Coding)",
+        capabilities: { input: ["text", "image", "document", "file"] },
+        limits: { contextWindow: 1_048_576, maxOutputTokens: 64_000 },
+        compat: {
+            route: "anthropic",
+            preserveThinking: true,
+            // Coding docs: low / high / max (default max).
+            reasoning_effort: "max",
+        },
     }),
 ];
+/**
+ * Featured Moonshot Open Platform offline bootstrap aliases — official Open Platform
+ * ids from https://platform.kimi.ai/docs/models. Callable via `createMoonshotProvider`
+ * when `includeMoonshotModels: true`. Refresh via `listKimiModels()`.
+ */
 export const moonshotKimiModels = [
     defineKimiModel({
         provider: "moonshot",
-        model: "kimi-k2.7-code-preview",
-        displayName: "Kimi K2.7 Code Preview",
+        model: "kimi-k2.7-code",
+        displayName: "Kimi K2.7 Code",
+        capabilities: { input: ["text"] },
         limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
-        compat: { route: "openai", preserveThinking: true },
+        compat: {
+            route: "openai",
+            // Official: omit `thinking` for K2.7-code; Preserved Thinking still required on replay.
+            preserveThinking: true,
+        },
+    }),
+    defineKimiModel({
+        provider: "moonshot",
+        model: "kimi-k3",
+        displayName: "Kimi K3",
+        capabilities: { input: ["text", "image"] },
+        limits: { contextWindow: 1_048_576, maxOutputTokens: 64_000 },
+        compat: {
+            route: "openai",
+            preserveThinking: true,
+            // Open Platform currently documents only `"max"`.
+            reasoning_effort: "max",
+        },
     }),
 ];
+function looksLikeReasoningModel(modelId) {
+    const id = modelId.toLowerCase();
+    return (id.includes("kimi-k3")
+        || id === "k3"
+        || id.includes("k2.7")
+        || id.includes("k2.6")
+        || id.includes("k2.5")
+        || id.includes("thinking")
+        || id.includes("for-coding"));
+}
+function shouldPreserveThinkingByDefault(modelId) {
+    const id = modelId.toLowerCase();
+    // Official: K2.7-code / Coding always preserve; K3 requires historical reasoning_content.
+    return id.includes("k2.7") || id.includes("for-coding") || id.includes("kimi-k3") || id === "k3";
+}
+function thinkingDefaultsForModel(modelId) {
+    const id = modelId.toLowerCase();
+    if (id.includes("kimi-k3") || id === "k3") {
+        return { reasoning_effort: "max" };
+    }
+    // Official: K2.7-code thinking is always on — omit the parameter unless the host sets it.
+    if (id.includes("k2.6") || id.includes("k2.5")) {
+        return { thinking: { type: "enabled" } };
+    }
+    return {};
+}
+function cleanLimits(value) {
+    const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function cleanJson(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
 //# sourceMappingURL=models.js.map

package/dist/moonshot.d.ts

@@ -0,0 +1,23 @@
+import type { AIProvider, CredentialValueSource, JsonObject, Message, ModelCapabilities, ProviderEvent, ProviderRequest } from "@arnilo/prism";
+export interface MoonshotProviderOptions {
+    readonly id?: string;
+    /** Defaults to Open Platform `https://api.moonshot.ai/v1`. */
+    readonly baseUrl?: string;
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+}
+/**
+ * Moonshot / Kimi Open Platform Chat Completions provider (`POST /chat/completions`).
+ * Official base: `https://api.moonshot.ai/v1` (or `api.moonshot.cn/v1`).
+ * Distinct from Kimi For Coding Anthropic `/messages` (`createKimiCodingProvider`).
+ * @see https://platform.kimi.ai/docs/api/overview
+ */
+export declare function createMoonshotProvider(options?: MoonshotProviderOptions): AIProvider;
+export declare function moonshotBody(request: ProviderRequest): JsonObject;
+export declare function moonshotEvents(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<ProviderEvent>;
+/**
+ * Open Platform message serialization. When `preserveThinking`, historical thinking
+ * blocks become top-level `reasoning_content` (official Preserved Thinking contract).
+ * Anthropic `cache_control` is never emitted on this route.
+ */
+export declare function serializeMoonshotMessage(message: Message, capabilities?: ModelCapabilities, preserveThinking?: boolean): JsonObject;

package/dist/moonshot.js

@@ -0,0 +1,175 @@
+import { assertStructuredOutputRequestSupported, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent, } from "@arnilo/prism";
+import { applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAITool, } from "@arnilo/prism/providers/openai";
+import { parseJsonObjectArguments, readBoundedResponseText, readSseData } from "@arnilo/prism/providers/transport";
+import { kimiPreserveThinking, kimiReasoningEffort, kimiThinking, stripKimiThinkingCompat, } from "./thinking.js";
+/**
+ * Moonshot / Kimi Open Platform Chat Completions provider (`POST /chat/completions`).
+ * Official base: `https://api.moonshot.ai/v1` (or `api.moonshot.cn/v1`).
+ * Distinct from Kimi For Coding Anthropic `/messages` (`createKimiCodingProvider`).
+ * @see https://platform.kimi.ai/docs/api/overview
+ */
+export function createMoonshotProvider(options = {}) {
+    const id = options.id ?? "moonshot";
+    const baseUrl = (options.baseUrl ?? "https://api.moonshot.ai/v1").replace(/\/$/, "");
+    return {
+        id,
+        async *generate(request) {
+            if (request.signal?.aborted)
+                throw request.signal.reason ?? new Error("aborted");
+            let token;
+            const secrets = [];
+            try {
+                const body = moonshotBody(request);
+                token = await resolveCredentialValue(options.apiKey, { provider: id, name: "apiKey" });
+                secrets.push(token);
+                const response = await (options.fetch ?? fetch)(`${baseUrl}/chat/completions`, {
+                    method: "POST",
+                    headers: {
+                        ...request.options?.headers,
+                        "content-type": "application/json",
+                        ...(token ? { authorization: `Bearer ${token}` } : {}),
+                    },
+                    body: JSON.stringify(body),
+                    signal: request.signal,
+                });
+                if (!response.ok) {
+                    return yield providerError(new Error(`Moonshot request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), secrets);
+                }
+                if (!response.body)
+                    return yield providerError(new Error("Moonshot response had no body"), secrets);
+                yield* moonshotEvents(response.body, request.signal);
+            }
+            catch (error) {
+                yield providerError(error, secrets);
+            }
+        },
+    };
+}
+export function moonshotBody(request) {
+    assertStructuredOutputRequestSupported(request.model, request.options);
+    const preserveThinking = kimiPreserveThinking(request);
+    const { maxTokens, ...parameters } = request.model.parameters ?? {};
+    const body = {
+        model: request.model.model,
+        messages: request.messages.map((message) => serializeMoonshotMessage(message, request.model.capabilities ?? {}, preserveThinking)),
+        tools: request.tools?.map(serializeOpenAITool),
+        stream: true,
+        stream_options: { include_usage: true },
+        thinking: kimiThinking(request),
+        reasoning_effort: kimiReasoningEffort(request),
+        ...parameters,
+        max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens,
+        ...stripKimiThinkingCompat(request.options?.compat),
+        ...request.options?.extra,
+    };
+    applyOpenAIChatStructuredOutput(body, request.options?.structuredOutput);
+    return clean(body);
+}
+export async function* moonshotEvents(body, signal) {
+    const tools = new Map();
+    let usage;
+    for await (const data of readSseData(body, { signal })) {
+        if (data === "[DONE]")
+            break;
+        const chunk = JSON.parse(data);
+        usage = mapOpenAIChatUsage(chunk.usage) ?? usage;
+        if (chunk.usage) {
+            const mapped = mapOpenAIChatUsage(chunk.usage);
+            if (mapped)
+                yield providerUsage(mapped);
+        }
+        for (const choice of chunk.choices ?? []) {
+            const delta = choice.delta ?? {};
+            if (delta.content)
+                yield providerTextDelta(delta.content);
+            if (delta.reasoning_content)
+                yield providerThinkingDelta(delta.reasoning_content);
+            for (const tool of delta.tool_calls ?? []) {
+                const index = tool.index ?? 0;
+                const current = tools.get(index) ?? { argumentsText: "" };
+                current.id = tool.id ?? current.id;
+                current.name = tool.function?.name ?? current.name;
+                current.argumentsText += tool.function?.arguments ?? "";
+                tools.set(index, current);
+                yield providerToolCallDelta({
+                    index,
+                    id: tool.id,
+                    name: tool.function?.name,
+                    argumentsText: tool.function?.arguments,
+                });
+            }
+        }
+    }
+    for (const call of tools.values()) {
+        if (call.id && call.name) {
+            yield providerToolCall(toolCallContent(call.id, call.name, parseJsonObjectArguments(call.argumentsText, { toolName: call.name })));
+        }
+    }
+    yield providerDone(usage);
+}
+/**
+ * Open Platform message serialization. When `preserveThinking`, historical thinking
+ * blocks become top-level `reasoning_content` (official Preserved Thinking contract).
+ * Anthropic `cache_control` is never emitted on this route.
+ */
+export function serializeMoonshotMessage(message, capabilities = {}, preserveThinking = false) {
+    if (message.role === "tool") {
+        const result = message.content.find((part) => part.type === "tool_result");
+        return {
+            role: "tool",
+            tool_call_id: result?.toolCallId ?? "",
+            content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
+        };
+    }
+    if (message.role === "assistant") {
+        const toolCalls = message.content.filter((part) => part.type === "tool_call");
+        const textParts = message.content.filter((part) => part.type === "text");
+        const thinkingParts = message.content.filter((part) => part.type === "thinking");
+        const text = textParts.map((part) => part.text).join("\n");
+        const reasoning = thinkingParts.map((part) => part.text).join("\n");
+        const base = {
+            role: "assistant",
+            content: text || (toolCalls.length > 0 ? null : ""),
+        };
+        if (preserveThinking && reasoning)
+            base.reasoning_content = reasoning;
+        if (toolCalls.length > 0) {
+            base.tool_calls = toolCalls.map((call) => ({
+                id: call.id,
+                type: "function",
+                function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+            }));
+        }
+        return base;
+    }
+    // user / system — fold thinking into text (should not normally appear)
+    const content = [];
+    for (const part of message.content) {
+        if (part.type === "text" || part.type === "thinking") {
+            content.push({ type: "text", text: part.text });
+        }
+        else if (part.type === "image") {
+            if (!capabilities.input?.includes("image")) {
+                throw new Error(`Moonshot ${message.role} message includes image but model does not declare image input capability`);
+            }
+            const url = part.url ?? (part.data ? `data:${part.mimeType ?? "image/png"};base64,${part.data}` : undefined);
+            if (!url)
+                throw new Error("Moonshot image block missing url or data");
+            content.push({ type: "image_url", image_url: { url } });
+        }
+        else if (part.type === "audio" || part.type === "file" || part.type === "document") {
+            throw new Error(`Moonshot Chat Completions does not support ${part.type} content blocks`);
+        }
+        else if (part.type === "tool_call" || part.type === "tool_result") {
+            throw new Error(`Moonshot ${part.type} blocks must use assistant/tool roles`);
+        }
+    }
+    if (content.length === 1 && content[0].type === "text") {
+        return { role: message.role, content: content[0].text };
+    }
+    return { role: message.role, content };
+}
+function clean(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && !(Array.isArray(item) && item.length === 0)));
+}
+//# sourceMappingURL=moonshot.js.map

package/dist/provider.js

@@ -2,6 +2,7 @@ import { assertStructuredOutputRequestSupported, providerDone, providerError, pr
 import { bytesToBase64, isPdfMediaType, rejectProviderMediaBlock, resolveProviderMediaMessages, serializePdfDocumentWireBlock, } from "@arnilo/prism/providers/media";
 import { parseJsonObjectArguments, readBoundedResponseText, readSseData } from "@arnilo/prism/providers/transport";
 import { applyKimiAnthropicCacheControl } from "./cache.js";
+import { kimiPreserveThinking, kimiReasoningEffort, kimiThinking, stripKimiThinkingCompat, } from "./thinking.js";
 export function createKimiCodingProvider(options = {}) {
     const id = options.id ?? "kimi-coding";
     const baseUrl = (options.baseUrl ?? "https://api.kimi.com/coding").replace(/\/$/, "");
@@ -42,19 +43,23 @@ export function createKimiCodingProvider(options = {}) {
 }
 export async function kimiAnthropicBody(request) {
     assertStructuredOutputRequestSupported(request.model, request.options);
-    const preserveThinking = request.model.compat?.preserveThinking === true;
+    const preserveThinking = kimiPreserveThinking(request);
     const { maxTokens, ...parameters } = request.model.parameters ?? {};
     const messages = applyKimiAnthropicCacheControl(request);
     const resolvedMedia = await resolveProviderMediaMessages(messages, request.model, { signal: request.signal });
+    // Official thinking/reasoning_effort fields (K2.x / K3) when documented for the model;
+    // Anthropic `/messages` contract remains under-documented — fields are best-effort passthrough.
     return clean({
         model: request.model.model,
         messages: await Promise.all(messages.filter((m) => m.role !== "system").map((message) => toMessage(message, request.model, preserveThinking, resolvedMedia))),
         system: messages.filter((m) => m.role === "system").map((m) => text(m, preserveThinking)).join("\n\n") || undefined,
         tools: request.tools?.map(toTool),
         stream: true,
+        thinking: kimiThinking(request),
+        reasoning_effort: kimiReasoningEffort(request),
         ...parameters,
         max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens ?? 4096,
-        ...request.options?.compat,
+        ...stripKimiThinkingCompat(request.options?.compat),
         ...request.options?.extra,
     });
 }

package/dist/thinking.d.ts

@@ -0,0 +1,22 @@
+import type { JsonObject, ProviderRequest } from "@arnilo/prism";
+/**
+ * Official K2.x Chat Completions / Anthropic-compat `thinking` object.
+ * Request `options.compat.thinking` wins over `model.compat.thinking`.
+ * @see https://platform.kimi.ai/docs/guide/use-kimi-k2-thinking-model
+ */
+export declare function kimiThinking(request: ProviderRequest): JsonObject | undefined;
+/**
+ * Official K3 top-level `reasoning_effort` (Open Platform currently documents `"max"`;
+ * Kimi Code additionally maps `low` / `high` / `max` for model id `k3`).
+ * Request wins over model default.
+ * @see https://platform.kimi.ai/docs/guide/use-thinking-effort
+ */
+export declare function kimiReasoningEffort(request: ProviderRequest): string | undefined;
+/**
+ * Whether to replay historical thinking blocks (Anthropic `thinking` content or
+ * Open Platform `reasoning_content`). K2.7-code / Coding models always preserve.
+ * Request `compat.preserveThinking` wins over model default.
+ */
+export declare function kimiPreserveThinking(request: ProviderRequest): boolean;
+/** Strip thinking-owned keys so opaque compat spread cannot invert explicit resolvers. */
+export declare function stripKimiThinkingCompat(compat: JsonObject | undefined): JsonObject;

package/dist/thinking.js

@@ -0,0 +1,42 @@
+/**
+ * Official K2.x Chat Completions / Anthropic-compat `thinking` object.
+ * Request `options.compat.thinking` wins over `model.compat.thinking`.
+ * @see https://platform.kimi.ai/docs/guide/use-kimi-k2-thinking-model
+ */
+export function kimiThinking(request) {
+    const value = request.options?.compat?.thinking ?? request.model.compat?.thinking;
+    if (value === false)
+        return { type: "disabled" };
+    if (value && typeof value === "object")
+        return value;
+    return value === true ? { type: "enabled" } : undefined;
+}
+/**
+ * Official K3 top-level `reasoning_effort` (Open Platform currently documents `"max"`;
+ * Kimi Code additionally maps `low` / `high` / `max` for model id `k3`).
+ * Request wins over model default.
+ * @see https://platform.kimi.ai/docs/guide/use-thinking-effort
+ */
+export function kimiReasoningEffort(request) {
+    const effort = request.options?.compat?.reasoning_effort
+        ?? request.options?.compat?.reasoningEffort
+        ?? request.model.compat?.reasoning_effort;
+    return typeof effort === "string" ? effort : undefined;
+}
+/**
+ * Whether to replay historical thinking blocks (Anthropic `thinking` content or
+ * Open Platform `reasoning_content`). K2.7-code / Coding models always preserve.
+ * Request `compat.preserveThinking` wins over model default.
+ */
+export function kimiPreserveThinking(request) {
+    const value = request.options?.compat?.preserveThinking ?? request.model.compat?.preserveThinking;
+    return value === true;
+}
+/** Strip thinking-owned keys so opaque compat spread cannot invert explicit resolvers. */
+export function stripKimiThinkingCompat(compat) {
+    if (!compat)
+        return {};
+    const { thinking: _thinking, reasoning_effort: _effort, reasoningEffort: _effortCamel, preserveThinking: _preserve, ...rest } = compat;
+    return rest;
+}
+//# sourceMappingURL=thinking.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-provider-kimi",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Kimi provider package for Prism.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "pack:dry-run": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.5"
+    "@arnilo/prism": "0.0.6"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../.."