@arnilo/prism-provider-kimi 0.0.3 → 0.0.5

package/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.5] - 2026-07-16
+
+- Pinned the required `@arnilo/prism` peer and package metadata to 0.0.5; runtime behavior is unchanged.
+
+
+## [0.0.4] - 2026-07-14
+
+### Changed
+
+- Migrated streaming/error handling to shared bounded transport and OpenAI/Anthropic argument helpers; documented structured-output capability, reasoning, cache, telemetry, and protected-header behavior.
+
 ## [0.0.2] - 2026-07-05
 
 ### Added

package/dist/models.js

@@ -6,6 +6,7 @@ export const kimiCodingModels = [
         provider: "kimi-coding",
         model: "kimi-k2.7-code",
         displayName: "Kimi K2.7 Code",
+        capabilities: { input: ["text", "document", "file"] },
         limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
         compat: { route: "anthropic", preserveThinking: true },
     }),

package/dist/provider.d.ts

@@ -7,5 +7,5 @@ export interface KimiCodingProviderOptions {
     readonly userAgent?: string;
 }
 export declare function createKimiCodingProvider(options?: KimiCodingProviderOptions): AIProvider;
-export declare function kimiAnthropicBody(request: ProviderRequest): JsonObject;
-export declare function kimiAnthropicEvents(body: ReadableStream<Uint8Array>): AsyncIterable<ProviderEvent>;
+export declare function kimiAnthropicBody(request: ProviderRequest): Promise<JsonObject>;
+export declare function kimiAnthropicEvents(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<ProviderEvent>;

package/dist/provider.js

@@ -1,6 +1,7 @@
-import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent } from "@arnilo/prism";
+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 { applyKimiAnthropicCacheControl } from "./cache.js";
-import { readSseData } from "./sse.js";
 export function createKimiCodingProvider(options = {}) {
     const id = options.id ?? "kimi-coding";
     const baseUrl = (options.baseUrl ?? "https://api.kimi.com/coding").replace(/\/$/, "");
@@ -9,9 +10,12 @@ export function createKimiCodingProvider(options = {}) {
         async *generate(request) {
             if (request.signal?.aborted)
                 throw request.signal.reason ?? new Error("aborted");
-            const token = await resolveCredentialValue(options.apiKey, { provider: id, name: "apiKey" });
-            const secrets = [token];
+            let token;
+            const secrets = [];
             try {
+                const body = await kimiAnthropicBody(request);
+                token = await resolveCredentialValue(options.apiKey, { provider: id, name: "apiKey" });
+                secrets.push(token);
                 const response = await (options.fetch ?? fetch)(`${baseUrl}/messages`, {
                     method: "POST",
                     headers: {
@@ -20,14 +24,15 @@ export function createKimiCodingProvider(options = {}) {
                         "user-agent": options.userAgent ?? "KimiCLI/1.5",
                         ...(token ? { authorization: `Bearer ${token}` } : {}),
                     },
-                    body: JSON.stringify(kimiAnthropicBody(request)),
+                    body: JSON.stringify(body),
                     signal: request.signal,
                 });
-                if (!response.ok)
-                    return yield providerError(new Error(`Kimi request failed: ${response.status} ${await safeText(response)}`), secrets);
+                if (!response.ok) {
+                    return yield providerError(new Error(`Kimi request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), secrets);
+                }
                 if (!response.body)
                     return yield providerError(new Error("Kimi response had no body"), secrets);
-                yield* kimiAnthropicEvents(response.body);
+                yield* kimiAnthropicEvents(response.body, request.signal);
             }
             catch (error) {
                 yield providerError(error, secrets);
@@ -35,13 +40,15 @@ export function createKimiCodingProvider(options = {}) {
         },
     };
 }
-export function kimiAnthropicBody(request) {
+export async function kimiAnthropicBody(request) {
+    assertStructuredOutputRequestSupported(request.model, request.options);
     const preserveThinking = request.model.compat?.preserveThinking === true;
     const { maxTokens, ...parameters } = request.model.parameters ?? {};
     const messages = applyKimiAnthropicCacheControl(request);
+    const resolvedMedia = await resolveProviderMediaMessages(messages, request.model, { signal: request.signal });
     return clean({
         model: request.model.model,
-        messages: messages.filter((m) => m.role !== "system").map((message) => toMessage(message, request.model.capabilities ?? {}, preserveThinking)),
+        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,
@@ -51,10 +58,10 @@ export function kimiAnthropicBody(request) {
         ...request.options?.extra,
     });
 }
-export async function* kimiAnthropicEvents(body) {
+export async function* kimiAnthropicEvents(body, signal) {
     const blocks = new Map();
     let usage;
-    for await (const data of readSseData(body)) {
+    for await (const data of readSseData(body, { signal })) {
         if (data === "[DONE]")
             break;
         const event = JSON.parse(data);
@@ -78,12 +85,15 @@ export async function* kimiAnthropicEvents(body) {
         if (event.type === "message_delta" && usage)
             yield providerUsage(usage);
     }
-    for (const call of blocks.values())
-        if (call.id && call.name)
-            yield providerToolCall(toolCallContent(call.id, call.name, parseArgs(call.argumentsText)));
+    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 providerDone(usage);
 }
-function toMessage(message, capabilities = {}, preserveThinking = false) {
+async function toMessage(message, model, preserveThinking, resolvedMedia) {
+    const capabilities = model.capabilities ?? {};
     if (message.role === "tool") {
         const result = message.content.find((part) => part.type === "tool_result");
         const last = message.content[message.content.length - 1];
@@ -112,14 +122,19 @@ function toMessage(message, capabilities = {}, preserveThinking = false) {
             }
         }
         else if (part.type === "image") {
-            if (!capabilities.input?.includes("image")) {
-                throw new Error(`Kimi request includes image but model does not declare image input capability`);
-            }
-            const source = part.url
-                ? { type: "url", url: part.url }
-                : { type: "base64", media_type: part.mimeType ?? "image/png", data: part.data ?? "" };
+            const resolved = resolvedMedia.get(part);
+            const source = { type: "base64", media_type: resolved.mediaType, data: bytesToBase64(resolved.bytes) };
             content.push(withMarker({ type: "image", source }, marker));
         }
+        else if (part.type === "document") {
+            content.push(withMarker(toAnthropicDocument(part, resolvedMedia), marker));
+        }
+        else if (part.type === "file") {
+            content.push(withMarker(toAnthropicFile(part, resolvedMedia), marker));
+        }
+        else if (part.type === "audio") {
+            rejectProviderMediaBlock(part, capabilities, model);
+        }
         else if (part.type === "tool_call") {
             content.push(withMarker({ type: "tool_use", id: part.id, name: part.name, input: part.arguments }, marker));
         }
@@ -129,6 +144,25 @@ function toMessage(message, capabilities = {}, preserveThinking = false) {
     }
     return { role: message.role === "assistant" ? "assistant" : "user", content: content.length > 0 ? content : [{ type: "text", text: "" }] };
 }
+function toAnthropicDocument(part, resolvedMedia) {
+    const resolved = resolvedMedia.get(part);
+    return serializePdfDocumentWireBlock({
+        mediaType: resolved.mediaType,
+        data: bytesToBase64(resolved.bytes),
+        title: resolved.name,
+    });
+}
+function toAnthropicFile(part, resolvedMedia) {
+    const resolved = resolvedMedia.get(part);
+    if (!isPdfMediaType(resolved.mediaType)) {
+        throw new Error(`Kimi Anthropic route only maps PDF file blocks; got ${resolved.mediaType}`);
+    }
+    return serializePdfDocumentWireBlock({
+        mediaType: resolved.mediaType,
+        data: bytesToBase64(resolved.bytes),
+        title: resolved.name,
+    });
+}
 function withMarker(item, marker) {
     return marker ? { ...item, cache_control: marker } : item;
 }
@@ -147,21 +181,7 @@ function text(message, preserveThinking = false) {
 function toUsage(usage) {
     return usage ? { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens, cacheReadTokens: usage.cache_read_input_tokens, cacheWriteTokens: usage.cache_creation_input_tokens } : undefined;
 }
-function parseArgs(text) {
-    if (!text)
-        return {};
-    const parsed = JSON.parse(text);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-}
 function clean(value) {
     return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && !(Array.isArray(item) && item.length === 0)));
 }
-async function safeText(response) {
-    try {
-        return await response.text();
-    }
-    catch {
-        return "";
-    }
-}
 //# sourceMappingURL=provider.js.map

package/package.json

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

package/dist/sse.d.ts

@@ -1 +0,0 @@
-export declare function readSseData(body: ReadableStream<Uint8Array>): AsyncIterable<string>;

package/dist/sse.js

@@ -1,24 +0,0 @@
-export async function* readSseData(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const parts = buffer.split(/\r?\n\r?\n/);
-        buffer = parts.pop() ?? "";
-        for (const part of parts)
-            yield* eventData(part);
-    }
-    buffer += decoder.decode();
-    if (buffer)
-        yield* eventData(buffer);
-}
-function* eventData(event) {
-    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
-    if (data)
-        yield data;
-}
-//# sourceMappingURL=sse.js.map