@arnilo/prism-provider-kimi 0.0.7 → 0.0.10

package/CHANGELOG.md

@@ -1,4 +1,40 @@
 # Changelog
+## [0.0.10] - 2026-07-21
+
+### Changed
+
+- Released with exact 0.0.10 graph.
+
+## [0.0.96] - 2026-07-21
+
+### Changed
+
+- Released with exact 0.0.96 graph.
+
+## [0.0.9] - 2026-07-21
+
+- Released with the exact 0.0.9 first-party package graph.
+
+### Fixed
+
+- Malformed streamed tool-call arguments yield recoverable tool calls via `toolCallFromArgumentsText` instead of throwing `ProviderTransportError` / terminal stream errors.
+
+
+## [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.

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

@@ -1,7 +1,7 @@
-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";
+import { assertStructuredOutputRequestSupported, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallFromArgumentsText } from "@arnilo/prism";
+import { applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAITool } from "@arnilo/prism/providers/openai";
+import { 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`).
@@ -27,10 +27,10 @@ export function createMoonshotProvider(options = {}) {
                     headers: {
                         ...request.options?.headers,
                         "content-type": "application/json",
-                        ...(token ? { authorization: `Bearer ${token}` } : {}),
+                        ...(token ? { authorization: `Bearer ${token}` } : {})
                     },
                     body: JSON.stringify(body),
-                    signal: request.signal,
+                    signal: request.signal
                 });
                 if (!response.ok) {
                     return yield providerError(new Error(`Moonshot request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), secrets);
@@ -42,7 +42,7 @@ export function createMoonshotProvider(options = {}) {
             catch (error) {
                 yield providerError(error, secrets);
             }
-        },
+        }
     };
 }
 export function moonshotBody(request) {
@@ -60,7 +60,7 @@ export function moonshotBody(request) {
         ...parameters,
         max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens,
         ...stripKimiThinkingCompat(request.options?.compat),
-        ...request.options?.extra,
+        ...request.options?.extra
     };
     applyOpenAIChatStructuredOutput(body, request.options?.structuredOutput);
     return clean(body);
@@ -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);
@@ -95,15 +101,22 @@ export async function* moonshotEvents(body, signal) {
                     index,
                     id: tool.id,
                     name: tool.function?.name,
-                    argumentsText: tool.function?.arguments,
+                    argumentsText: tool.function?.arguments
                 });
             }
         }
     }
+    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(toolCallFromArgumentsText(call.id, call.name, call.argumentsText));
     }
     yield providerDone(usage);
 }
@@ -118,7 +131,7 @@ export function serializeMoonshotMessage(message, capabilities = {}, preserveThi
         return {
             role: "tool",
             tool_call_id: result?.toolCallId ?? "",
-            content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
+            content: result ? JSON.stringify(result.result ?? result.error ?? null) : ""
         };
     }
     if (message.role === "assistant") {
@@ -129,7 +142,7 @@ export function serializeMoonshotMessage(message, capabilities = {}, preserveThi
         const reasoning = thinkingParts.map((part) => part.text).join("\n");
         const base = {
             role: "assistant",
-            content: text || (toolCalls.length > 0 ? null : ""),
+            content: text || (toolCalls.length > 0 ? null : "")
         };
         if (preserveThinking && reasoning)
             base.reasoning_content = reasoning;
@@ -137,7 +150,7 @@ export function serializeMoonshotMessage(message, capabilities = {}, preserveThi
             base.tool_calls = toolCalls.map((call) => ({
                 id: call.id,
                 type: "function",
-                function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+                function: { name: call.name, arguments: JSON.stringify(call.arguments) }
             }));
         }
         return base;

package/dist/provider.js

@@ -1,8 +1,8 @@
-import { assertStructuredOutputRequestSupported, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent } from "@arnilo/prism";
-import { bytesToBase64, isPdfMediaType, rejectProviderMediaBlock, resolveProviderMediaMessages, serializePdfDocumentWireBlock, } from "@arnilo/prism/providers/media";
-import { parseJsonObjectArguments, readBoundedResponseText, readSseData } from "@arnilo/prism/providers/transport";
+import { assertStructuredOutputRequestSupported, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallFromArgumentsText } from "@arnilo/prism";
+import { bytesToBase64, isPdfMediaType, rejectProviderMediaBlock, resolveProviderMediaMessages, serializePdfDocumentWireBlock } from "@arnilo/prism/providers/media";
+import { readBoundedResponseText, readSseData } from "@arnilo/prism/providers/transport";
 import { applyKimiAnthropicCacheControl } from "./cache.js";
-import { kimiPreserveThinking, kimiReasoningEffort, kimiThinking, stripKimiThinkingCompat, } from "./thinking.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(/\/$/, "");
@@ -24,9 +24,12 @@ 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,
+                    signal: request.signal
                 });
                 if (!response.ok) {
                     return yield providerError(new Error(`Kimi request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), secrets);
@@ -38,7 +41,7 @@ export function createKimiCodingProvider(options = {}) {
             catch (error) {
                 yield providerError(error, secrets);
             }
-        },
+        }
     };
 }
 export async function kimiAnthropicBody(request) {
@@ -60,18 +63,26 @@ export async function kimiAnthropicBody(request) {
         ...parameters,
         max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens ?? 4096,
         ...stripKimiThinkingCompat(request.options?.compat),
-        ...request.options?.extra,
+        ...request.options?.extra
     });
 }
 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(toolCallFromArgumentsText(call.id, call.name, call.argumentsText));
     }
     yield providerDone(usage);
 }
@@ -108,8 +125,8 @@ async function toMessage(message, model, preserveThinking, resolvedMedia) {
                     type: "tool_result",
                     tool_use_id: result?.toolCallId ?? "",
                     content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
-                    ...(last?.cache_control ? { cache_control: last.cache_control } : {}),
-                }],
+                    ...(last?.cache_control ? { cache_control: last.cache_control } : {})
+                }]
         };
     }
     const content = [];
@@ -154,7 +171,7 @@ function toAnthropicDocument(part, resolvedMedia) {
     return serializePdfDocumentWireBlock({
         mediaType: resolved.mediaType,
         data: bytesToBase64(resolved.bytes),
-        title: resolved.name,
+        title: resolved.name
     });
 }
 function toAnthropicFile(part, resolvedMedia) {
@@ -165,7 +182,7 @@ function toAnthropicFile(part, resolvedMedia) {
     return serializePdfDocumentWireBlock({
         mediaType: resolved.mediaType,
         data: bytesToBase64(resolved.bytes),
-        title: resolved.name,
+        title: resolved.name
     });
 }
 function withMarker(item, marker) {

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.7",
+  "version": "0.0.10",
   "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.7"
+    "@arnilo/prism": "0.0.10"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../.."