@arnilo/prism-provider-kimi 0.0.6 → 0.0.8

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.0.8] - 2026-07-20
+
+- Released with the exact 0.0.8 first-party package graph.
+
+### Added
+
+- Featured Moonshot catalog adds `kimi-k2.7-code-highspeed`, `kimi-k2.6`, and `kimi-k2.5` with official thinking defaults (K2.5 intentionally without Preserved Thinking).
+
+### Fixed
+
+- Featured Coding `k3` defaults `reasoning_effort: "high"` per official Kimi Code docs (Open Platform `kimi-k3` keeps `"max"`); 256K-class featured context windows corrected to the exact official `262_144`.
+- `stripKimiThinkingCompat()` also strips `route` and `preserve_thinking`, so provider-owned routing/serialization keys no longer leak into Anthropic or Chat Completions request bodies.
+- Coding route sends provider-owned `x-api-key` and `anthropic-version: 2023-06-01` headers alongside Bearer per the official third-party setup; caller headers cannot override them.
+- Both stream parsers require protocol completion evidence (`message_stop` on the Coding route, `[DONE]` + terminal `finish_reason` on the Moonshot route) and complete tool-call accumulators; truncated streams end with a terminal `error` instead of a false `done`.
+
+## [0.0.7] - 2026-07-19
+
+- Released with the exact 0.0.7 first-party package graph.
+
 All notable changes to @arnilo/prism-provider-kimi will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),

package/dist/models.d.ts

@@ -6,7 +6,7 @@ export interface KimiModelConfig extends Omit<ModelConfig, "provider" | "compat"
         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`). */
+        /** Official K3 `reasoning_effort` (`"low"`/`"high"`/`"max"`; Open Platform default `"max"`, Coding default `"high"`). */
         readonly reasoning_effort?: string;
     };
 }
@@ -62,4 +62,4 @@ export declare const kimiCodingModels: readonly [ModelConfig, ModelConfig, Model
  * ids from https://platform.kimi.ai/docs/models. Callable via `createMoonshotProvider`
  * when `includeMoonshotModels: true`. Refresh via `listKimiModels()`.
  */
-export declare const moonshotKimiModels: readonly [ModelConfig, ModelConfig];
+export declare const moonshotKimiModels: readonly [ModelConfig, ModelConfig, ModelConfig, ModelConfig, ModelConfig];

package/dist/models.js

@@ -89,7 +89,7 @@ export const kimiCodingModels = [
         model: "kimi-for-coding",
         displayName: "Kimi For Coding (K2.7 Code)",
         capabilities: { input: ["text", "document", "file"] },
-        limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
+        limits: { contextWindow: 262_144, maxOutputTokens: 64_000 },
         compat: {
             route: "anthropic",
             // Official: thinking always on — omit `thinking` on the wire unless the host sets it.
@@ -101,7 +101,7 @@ export const kimiCodingModels = [
         model: "kimi-for-coding-highspeed",
         displayName: "Kimi For Coding Highspeed",
         capabilities: { input: ["text", "document", "file"] },
-        limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
+        limits: { contextWindow: 262_144, maxOutputTokens: 64_000 },
         compat: {
             route: "anthropic",
             preserveThinking: true,
@@ -116,8 +116,8 @@ export const kimiCodingModels = [
         compat: {
             route: "anthropic",
             preserveThinking: true,
-            // Coding docs: low / high / max (default max).
-            reasoning_effort: "max",
+            // Official Kimi Code docs: low / high / max; unset effort maps to "high".
+            reasoning_effort: "high",
         },
     }),
 ];
@@ -132,13 +132,49 @@ export const moonshotKimiModels = [
         model: "kimi-k2.7-code",
         displayName: "Kimi K2.7 Code",
         capabilities: { input: ["text"] },
-        limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
+        limits: { contextWindow: 262_144, maxOutputTokens: 64_000 },
         compat: {
             route: "openai",
             // Official: omit `thinking` for K2.7-code; Preserved Thinking still required on replay.
             preserveThinking: true,
         },
     }),
+    defineKimiModel({
+        provider: "moonshot",
+        model: "kimi-k2.7-code-highspeed",
+        displayName: "Kimi K2.7 Code Highspeed",
+        capabilities: { input: ["text"] },
+        limits: { contextWindow: 262_144, maxOutputTokens: 64_000 },
+        compat: {
+            route: "openai",
+            // Official: same model as kimi-k2.7-code with identical constraints; only output speed differs.
+            preserveThinking: true,
+        },
+    }),
+    defineKimiModel({
+        provider: "moonshot",
+        model: "kimi-k2.6",
+        displayName: "Kimi K2.6",
+        capabilities: { input: ["text"] },
+        limits: { contextWindow: 262_144, maxOutputTokens: 64_000 },
+        compat: {
+            route: "openai",
+            // Official: thinking `{"type":"enabled"}` default; `keep: "all"` opt-in.
+            thinking: { type: "enabled" },
+        },
+    }),
+    defineKimiModel({
+        provider: "moonshot",
+        model: "kimi-k2.5",
+        displayName: "Kimi K2.5",
+        capabilities: { input: ["text"] },
+        limits: { contextWindow: 262_144, maxOutputTokens: 64_000 },
+        compat: {
+            route: "openai",
+            // Official: thinking `{"type":"enabled"}` default; no Preserved Thinking support.
+            thinking: { type: "enabled" },
+        },
+    }),
     defineKimiModel({
         provider: "moonshot",
         model: "kimi-k3",
@@ -148,7 +184,7 @@ export const moonshotKimiModels = [
         compat: {
             route: "openai",
             preserveThinking: true,
-            // Open Platform currently documents only `"max"`.
+            // Official Open Platform: low / high / max (default max).
             reasoning_effort: "max",
         },
     }),

package/dist/moonshot.js

@@ -68,9 +68,13 @@ export function moonshotBody(request) {
 export async function* moonshotEvents(body, signal) {
     const tools = new Map();
     let usage;
+    let sawDoneMarker = false;
+    let sawFinishReason = false;
     for await (const data of readSseData(body, { signal })) {
-        if (data === "[DONE]")
+        if (data === "[DONE]") {
+            sawDoneMarker = true;
             break;
+        }
         const chunk = JSON.parse(data);
         usage = mapOpenAIChatUsage(chunk.usage) ?? usage;
         if (chunk.usage) {
@@ -79,6 +83,8 @@ export async function* moonshotEvents(body, signal) {
                 yield providerUsage(mapped);
         }
         for (const choice of chunk.choices ?? []) {
+            if (choice.finish_reason)
+                sawFinishReason = true;
             const delta = choice.delta ?? {};
             if (delta.content)
                 yield providerTextDelta(delta.content);
@@ -100,10 +106,17 @@ export async function* moonshotEvents(body, signal) {
             }
         }
     }
+    const danglingToolCall = [...tools.values()].some((call) => !call.id || !call.name);
+    if (!sawDoneMarker || !sawFinishReason || danglingToolCall) {
+        // Truncated streams must fail loudly — emitting done would mark partial output as succeeded.
+        yield providerError(new Error(`Moonshot chat stream ended without completion evidence `
+            + `([DONE]: ${sawDoneMarker ? "received" : "missing"}, `
+            + `finish_reason: ${sawFinishReason ? "received" : "missing"}, `
+            + `tool calls complete: ${danglingToolCall ? "no" : "yes"})`));
+        return;
+    }
     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 providerToolCall(toolCallContent(call.id, call.name, parseJsonObjectArguments(call.argumentsText, { toolName: call.name })));
     }
     yield providerDone(usage);
 }

package/dist/provider.js

@@ -24,6 +24,9 @@ export function createKimiCodingProvider(options = {}) {
                         "content-type": "application/json",
                         "user-agent": options.userAgent ?? "KimiCLI/1.5",
                         ...(token ? { authorization: `Bearer ${token}` } : {}),
+                        // Provider-owned Anthropic-route auth: official third-party setup uses
+                        // ANTHROPIC_API_KEY semantics (x-api-key + anthropic-version).
+                        ...(token ? { "x-api-key": token, "anthropic-version": "2023-06-01" } : {}),
                     },
                     body: JSON.stringify(body),
                     signal: request.signal,
@@ -66,12 +69,20 @@ export async function kimiAnthropicBody(request) {
 export async function* kimiAnthropicEvents(body, signal) {
     const blocks = new Map();
     let usage;
+    let sawMessageStop = false;
     for await (const data of readSseData(body, { signal })) {
         if (data === "[DONE]")
             break;
         const event = JSON.parse(data);
+        if (event.type === "message_stop")
+            sawMessageStop = true;
         if (event.type === "content_block_start" && event.content_block?.type === "tool_use")
             blocks.set(event.index ?? 0, { id: event.content_block.id, name: event.content_block.name, argumentsText: "" });
+        if (event.type === "content_block_stop") {
+            const current = blocks.get(event.index ?? 0);
+            if (current)
+                current.complete = true;
+        }
         if (event.type === "content_block_delta") {
             const delta = event.delta;
             if (delta?.type === "text_delta" && delta.text)
@@ -90,10 +101,16 @@ export async function* kimiAnthropicEvents(body, signal) {
         if (event.type === "message_delta" && usage)
             yield providerUsage(usage);
     }
+    const danglingBlock = [...blocks.values()].some((call) => !call.id || !call.name || !call.complete);
+    if (!sawMessageStop || danglingBlock) {
+        // Truncated streams must fail loudly — emitting done would mark partial output as succeeded.
+        yield providerError(new Error(`Kimi messages stream ended without completion evidence `
+            + `(message_stop: ${sawMessageStop ? "received" : "missing"}, `
+            + `content blocks complete: ${danglingBlock ? "no" : "yes"})`));
+        return;
+    }
     for (const call of blocks.values()) {
-        if (call.id && call.name) {
-            yield providerToolCall(toolCallContent(call.id, call.name, parseJsonObjectArguments(call.argumentsText, { toolName: call.name })));
-        }
+        yield providerToolCall(toolCallContent(call.id, call.name, parseJsonObjectArguments(call.argumentsText, { toolName: call.name })));
     }
     yield providerDone(usage);
 }

package/dist/thinking.d.ts

@@ -6,8 +6,8 @@ import type { JsonObject, ProviderRequest } from "@arnilo/prism";
  */
 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`).
+ * Official K3 top-level `reasoning_effort`: `"low"` / `"high"` / `"max"`.
+ * Open Platform default is `"max"`; Kimi Code default is `"high"`.
  * Request wins over model default.
  * @see https://platform.kimi.ai/docs/guide/use-thinking-effort
  */
@@ -18,5 +18,8 @@ export declare function kimiReasoningEffort(request: ProviderRequest): string |
  * 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. */
+/**
+ * Strip provider-owned compat keys so the opaque compat spread cannot leak
+ * routing/serialization directives (or inverted thinking values) into wire bodies.
+ */
 export declare function stripKimiThinkingCompat(compat: JsonObject | undefined): JsonObject;

package/dist/thinking.js

@@ -12,8 +12,8 @@ export function kimiThinking(request) {
     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`).
+ * Official K3 top-level `reasoning_effort`: `"low"` / `"high"` / `"max"`.
+ * Open Platform default is `"max"`; Kimi Code default is `"high"`.
  * Request wins over model default.
  * @see https://platform.kimi.ai/docs/guide/use-thinking-effort
  */
@@ -32,11 +32,14 @@ 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. */
+/**
+ * Strip provider-owned compat keys so the opaque compat spread cannot leak
+ * routing/serialization directives (or inverted thinking values) into wire bodies.
+ */
 export function stripKimiThinkingCompat(compat) {
     if (!compat)
         return {};
-    const { thinking: _thinking, reasoning_effort: _effort, reasoningEffort: _effortCamel, preserveThinking: _preserve, ...rest } = compat;
+    const { thinking: _thinking, reasoning_effort: _effort, reasoningEffort: _effortCamel, preserveThinking: _preserve, preserve_thinking: _preserveSnake, route: _route, ...rest } = compat;
     return rest;
 }
 //# sourceMappingURL=thinking.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-provider-kimi",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "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.6"
+    "@arnilo/prism": "0.0.8"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../.."