@arnilo/prism-provider-kimi 0.0.2 → 0.0.4

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 { assertProviderMediaCapability, bytesToBase64, isPdfMediaType, rejectProviderMediaBlock, resolveProviderMediaBlock, 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(/\/$/, "");
@@ -20,14 +21,15 @@ export function createKimiCodingProvider(options = {}) {
                         "user-agent": options.userAgent ?? "KimiCLI/1.5",
                         ...(token ? { authorization: `Bearer ${token}` } : {}),
                     },
-                    body: JSON.stringify(kimiAnthropicBody(request)),
+                    body: JSON.stringify(await kimiAnthropicBody(request)),
                     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 +37,14 @@ 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);
     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, request.signal))),
         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 +54,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 +81,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 = false, signal) {
+    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 +118,21 @@ 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`);
-            }
+            assertProviderMediaCapability("image", capabilities, model);
             const source = part.url
                 ? { type: "url", url: part.url }
                 : { type: "base64", media_type: part.mimeType ?? "image/png", data: part.data ?? "" };
             content.push(withMarker({ type: "image", source }, marker));
         }
+        else if (part.type === "document") {
+            content.push(withMarker(await toAnthropicDocument(part, model, signal), marker));
+        }
+        else if (part.type === "file") {
+            content.push(withMarker(await toAnthropicFile(part, model, signal), 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 +142,27 @@ function toMessage(message, capabilities = {}, preserveThinking = false) {
     }
     return { role: message.role === "assistant" ? "assistant" : "user", content: content.length > 0 ? content : [{ type: "text", text: "" }] };
 }
+async function toAnthropicDocument(part, model, signal) {
+    assertProviderMediaCapability("document", model.capabilities ?? {}, model);
+    const resolved = await resolveProviderMediaBlock(part, { signal });
+    return serializePdfDocumentWireBlock({
+        mediaType: resolved.mediaType,
+        data: bytesToBase64(resolved.bytes),
+        title: resolved.name,
+    });
+}
+async function toAnthropicFile(part, model, signal) {
+    assertProviderMediaCapability("file", model.capabilities ?? {}, model);
+    const resolved = await resolveProviderMediaBlock(part, { signal });
+    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.2",
+  "version": "0.0.4",
   "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.2"
+    "@arnilo/prism": "0.0.4"
   },
   "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