@arnilo/prism-provider-kimi 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.2] - 2026-07-05
+
 ### Added
 
 - Added `LICENSE` (MIT) and `CHANGELOG.md`.

package/README.md

@@ -20,3 +20,9 @@ Security defaults:
 - 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`.
+
+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`.
+- Provider-owned headers (`content-type`, `user-agent`, `authorization`) win over caller headers.

package/dist/cache.d.ts

@@ -0,0 +1,16 @@
+import type { Message, ProviderRequest } from "@arnilo/prism";
+/**
+ * Whether Anthropic-style content `cache_control` markers may be emitted on the
+ * Kimi coding (`/messages`) endpoint. Default catalog models use implicit
+ * caching and do not declare this; hosts opt in per-model via
+ * `ModelConfig.cache.kind: "cache_control"` (or force `cache.mode: "on"`).
+ * The Moonshot OpenAI-compatible route never receives Anthropic `cache_control`.
+ */
+export declare function kimiAnthropicCacheEnabled(request: ProviderRequest): boolean;
+/**
+ * Apply Anthropic-style `cache_control` markers only to the caller-selected Prism
+ * breakpoints on the Kimi Anthropic route, using the shared `applyCacheControl`
+ * helper. Markers land on the last content block of each selected message; with
+ * no breakpoints, no markers are emitted and the endpoint relies on implicit caching.
+ */
+export declare function applyKimiAnthropicCacheControl(request: ProviderRequest): readonly Message[];

package/dist/cache.js

@@ -0,0 +1,41 @@
+import { applyCacheControl } from "@arnilo/prism";
+/**
+ * Whether Anthropic-style content `cache_control` markers may be emitted on the
+ * Kimi coding (`/messages`) endpoint. Default catalog models use implicit
+ * caching and do not declare this; hosts opt in per-model via
+ * `ModelConfig.cache.kind: "cache_control"` (or force `cache.mode: "on"`).
+ * The Moonshot OpenAI-compatible route never receives Anthropic `cache_control`.
+ */
+export function kimiAnthropicCacheEnabled(request) {
+    if (request.options?.cacheRetention === "none")
+        return false;
+    if (request.options?.cache?.mode === "off")
+        return false;
+    if (request.model.cache?.kind === "none")
+        return false;
+    return request.model.cache?.kind === "cache_control" || request.options?.cache?.mode === "on";
+}
+/**
+ * Apply Anthropic-style `cache_control` markers only to the caller-selected Prism
+ * breakpoints on the Kimi Anthropic route, using the shared `applyCacheControl`
+ * helper. Markers land on the last content block of each selected message; with
+ * no breakpoints, no markers are emitted and the endpoint relies on implicit caching.
+ */
+export function applyKimiAnthropicCacheControl(request) {
+    if (!kimiAnthropicCacheEnabled(request))
+        return request.messages;
+    const breakpoints = request.options?.cache?.breakpoints;
+    if (!breakpoints?.length)
+        return request.messages;
+    const options = {
+        ttl: kimiAnthropicCacheTtl(request) ? "1h" : undefined,
+        maxBreakpoints: request.model.cache?.maxBreakpoints,
+    };
+    return applyCacheControl(request.messages, breakpoints, options);
+}
+function kimiAnthropicCacheTtl(request) {
+    if (request.options?.cacheRetention !== "long" && request.options?.cache?.retention !== "long")
+        return false;
+    return request.model.cache?.longRetention !== false;
+}
+//# sourceMappingURL=cache.js.map

package/dist/provider.js

@@ -1,4 +1,5 @@
 import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent } from "@arnilo/prism";
+import { applyKimiAnthropicCacheControl } from "./cache.js";
 import { readSseData } from "./sse.js";
 export function createKimiCodingProvider(options = {}) {
     const id = options.id ?? "kimi-coding";
@@ -14,9 +15,9 @@ export function createKimiCodingProvider(options = {}) {
                 const response = await (options.fetch ?? fetch)(`${baseUrl}/messages`, {
                     method: "POST",
                     headers: {
+                        ...request.options?.headers,
                         "content-type": "application/json",
                         "user-agent": options.userAgent ?? "KimiCLI/1.5",
-                        ...request.options?.headers,
                         ...(token ? { authorization: `Bearer ${token}` } : {}),
                     },
                     body: JSON.stringify(kimiAnthropicBody(request)),
@@ -36,14 +37,16 @@ export function createKimiCodingProvider(options = {}) {
 }
 export function kimiAnthropicBody(request) {
     const preserveThinking = request.model.compat?.preserveThinking === true;
+    const { maxTokens, ...parameters } = request.model.parameters ?? {};
+    const messages = applyKimiAnthropicCacheControl(request);
     return clean({
         model: request.model.model,
-        messages: request.messages.filter((m) => m.role !== "system").map((message) => toMessage(message, request.model.capabilities ?? {}, preserveThinking)),
-        system: request.messages.filter((m) => m.role === "system").map((m) => text(m, preserveThinking)).join("\n\n") || undefined,
+        messages: messages.filter((m) => m.role !== "system").map((message) => toMessage(message, request.model.capabilities ?? {}, preserveThinking)),
+        system: messages.filter((m) => m.role === "system").map((m) => text(m, preserveThinking)).join("\n\n") || undefined,
         tools: request.tools?.map(toTool),
         stream: true,
-        max_tokens: request.model.limits?.maxOutputTokens ?? 4096,
-        ...request.model.parameters,
+        ...parameters,
+        max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens ?? 4096,
         ...request.options?.compat,
         ...request.options?.extra,
     });
@@ -83,26 +86,29 @@ export async function* kimiAnthropicEvents(body) {
 function toMessage(message, capabilities = {}, preserveThinking = false) {
     if (message.role === "tool") {
         const result = message.content.find((part) => part.type === "tool_result");
+        const last = message.content[message.content.length - 1];
         return {
             role: "user",
             content: [{
                     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 } : {}),
                 }],
         };
     }
     const content = [];
     for (const part of message.content) {
+        const marker = (part.cache_control ?? undefined);
         if (part.type === "text") {
-            content.push({ type: "text", text: part.text });
+            content.push(withMarker({ type: "text", text: part.text }, marker));
         }
         else if (part.type === "thinking") {
             if (preserveThinking) {
-                content.push(part.signature ? { type: "thinking", thinking: part.text, signature: part.signature } : { type: "thinking", thinking: part.text });
+                content.push(withMarker(part.signature ? { type: "thinking", thinking: part.text, signature: part.signature } : { type: "thinking", thinking: part.text }, marker));
             }
             else {
-                content.push({ type: "text", text: part.text });
+                content.push(withMarker({ type: "text", text: part.text }, marker));
             }
         }
         else if (part.type === "image") {
@@ -112,10 +118,10 @@ function toMessage(message, capabilities = {}, preserveThinking = false) {
             const source = part.url
                 ? { type: "url", url: part.url }
                 : { type: "base64", media_type: part.mimeType ?? "image/png", data: part.data ?? "" };
-            content.push({ type: "image", source });
+            content.push(withMarker({ type: "image", source }, marker));
         }
         else if (part.type === "tool_call") {
-            content.push({ type: "tool_use", id: part.id, name: part.name, input: part.arguments });
+            content.push(withMarker({ type: "tool_use", id: part.id, name: part.name, input: part.arguments }, marker));
         }
         else if (part.type === "tool_result") {
             throw new Error("Kimi tool_result blocks must appear in role=tool messages");
@@ -123,6 +129,9 @@ function toMessage(message, capabilities = {}, preserveThinking = false) {
     }
     return { role: message.role === "assistant" ? "assistant" : "user", content: content.length > 0 ? content : [{ type: "text", text: "" }] };
 }
+function withMarker(item, marker) {
+    return marker ? { ...item, cache_control: marker } : item;
+}
 function toTool(tool) {
     return clean({ name: tool.name, description: tool.description, input_schema: tool.parameters ?? { type: "object" } });
 }

package/package.json

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