@arnilo/prism-provider-kimi 0.0.16 → 0.0.17

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.0.17] - 2026-07-29
+
+### Changed
+- HTTP errors now carry numeric `code` and parsed `Retry-After` (`retryAfterMs`) for transient classification and backpressure-aware retries.
+- Released with exact 0.0.17 graph.
+
 ## [0.0.16] - 2026-07-26
 
 ### Changed

package/dist/models.js

@@ -24,7 +24,7 @@ export function defineKimiModel(config) {
  */
 export async function listKimiModels(options = {}) {
     const provider = options.provider ?? "moonshot";
-    const baseUrl = (options.baseUrl ?? "https://api.moonshot.ai/v1").replace(/\/$/, "");
+    const baseUrl = (options.baseUrl ?? "https://api.moonshot.ai/v1").replace(/\/+$/, "");
     const token = await resolveCredentialValue(options.apiKey, { provider, name: "apiKey" });
     const response = await (options.fetch ?? fetch)(`${baseUrl}/models`, {
         method: "GET",

package/dist/moonshot.js

@@ -1,6 +1,5 @@
-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 { applyOpenAIChatStructuredOutput } from "@arnilo/prism/providers/openai";
+import { buildOpenAIChatBody, createOpenAICompatibleProvider, openAIChatEvents } from "@arnilo/prism/providers/openai-compatible";
 import { kimiPreserveThinking, kimiReasoningEffort, kimiThinking, stripKimiThinkingCompat } from "./thinking.js";
 /**
  * Moonshot / Kimi Open Platform Chat Completions provider (`POST /chat/completions`).
@@ -9,116 +8,39 @@ import { kimiPreserveThinking, kimiReasoningEffort, kimiThinking, stripKimiThink
  * @see https://platform.kimi.ai/docs/api/overview
  */
 export function createMoonshotProvider(options = {}) {
-    const id = options.id ?? "moonshot";
-    const baseUrl = (options.baseUrl ?? "https://api.moonshot.ai/v1").replace(/\/$/, "");
-    return {
-        id,
-        async *generate(request) {
-            if (request.signal?.aborted)
-                throw request.signal.reason ?? new Error("aborted");
-            let token;
-            const secrets = [];
-            try {
-                const body = moonshotBody(request);
-                token = await resolveCredentialValue(options.apiKey, { provider: id, name: "apiKey" });
-                secrets.push(token);
-                const response = await (options.fetch ?? fetch)(`${baseUrl}/chat/completions`, {
-                    method: "POST",
-                    headers: {
-                        ...request.options?.headers,
-                        "content-type": "application/json",
-                        ...(token ? { authorization: `Bearer ${token}` } : {}),
-                    },
-                    body: JSON.stringify(body),
-                    signal: request.signal,
-                });
-                if (!response.ok) {
-                    return yield providerError(new Error(`Moonshot request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), secrets);
-                }
-                if (!response.body)
-                    return yield providerError(new Error("Moonshot response had no body"), secrets);
-                yield* moonshotEvents(response.body, request.signal);
-            }
-            catch (error) {
-                yield providerError(error, secrets);
-            }
-        },
-    };
+    return createOpenAICompatibleProvider({
+        id: options.id ?? "moonshot",
+        baseUrl: (options.baseUrl ?? "https://api.moonshot.ai/v1").replace(/\/+$/, ""),
+        apiKey: options.apiKey,
+        fetch: options.fetch,
+        strictCompletion: true,
+        requestFailedPrefix: "Moonshot request failed",
+        serializeMessage: (message, request) => serializeMoonshotMessage(message, request.model.capabilities ?? {}, kimiPreserveThinking(request)),
+        transformBody: (body, request) => moonshotTransform(body, request),
+    });
 }
 export function moonshotBody(request) {
-    assertStructuredOutputRequestSupported(request.model, request.options);
-    const preserveThinking = kimiPreserveThinking(request);
-    const { maxTokens, ...parameters } = request.model.parameters ?? {};
-    const body = {
-        model: request.model.model,
-        messages: request.messages.map((message) => serializeMoonshotMessage(message, request.model.capabilities ?? {}, preserveThinking)),
-        tools: request.tools?.map(serializeOpenAITool),
-        stream: true,
-        stream_options: { include_usage: true },
+    return buildOpenAIChatBody(request, {
+        serializeMessage: (message, req) => serializeMoonshotMessage(message, req.model.capabilities ?? {}, kimiPreserveThinking(req)),
+        transformBody: (body, req) => moonshotTransform(body, req),
+    });
+}
+function moonshotTransform(body, request) {
+    const { maxTokens, ...rest } = body;
+    const transformed = {
+        // Resolved thinking fields first: model `parameters` may override them (legacy order).
         thinking: kimiThinking(request),
         reasoning_effort: kimiReasoningEffort(request),
-        ...parameters,
+        ...rest,
         max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens,
         ...stripKimiThinkingCompat(request.options?.compat),
         ...request.options?.extra,
     };
-    applyOpenAIChatStructuredOutput(body, request.options?.structuredOutput);
-    return clean(body);
+    applyOpenAIChatStructuredOutput(transformed, request.options?.structuredOutput);
+    return clean(transformed);
 }
-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]") {
-            sawDoneMarker = true;
-            break;
-        }
-        const chunk = JSON.parse(data);
-        usage = mapOpenAIChatUsage(chunk.usage) ?? usage;
-        if (chunk.usage) {
-            const mapped = mapOpenAIChatUsage(chunk.usage);
-            if (mapped)
-                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);
-            if (delta.reasoning_content)
-                yield providerThinkingDelta(delta.reasoning_content);
-            for (const tool of delta.tool_calls ?? []) {
-                const index = tool.index ?? 0;
-                const current = tools.get(index) ?? { argumentsText: "" };
-                current.id = tool.id ?? current.id;
-                current.name = tool.function?.name ?? current.name;
-                current.argumentsText += tool.function?.arguments ?? "";
-                tools.set(index, current);
-                yield providerToolCallDelta({
-                    index,
-                    id: tool.id,
-                    name: tool.function?.name,
-                    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()) {
-        yield providerToolCall(toolCallFromArgumentsText(call.id, call.name, call.argumentsText));
-    }
-    yield providerDone(usage);
+export function moonshotEvents(body, signal) {
+    return openAIChatEvents(body, { signal, strictCompletion: true });
 }
 /**
  * Open Platform message serialization. When `preserveThinking`, historical thinking

package/dist/provider.js

@@ -1,11 +1,11 @@
 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 { httpStatusError, readBoundedResponseText, readSseData } from "@arnilo/prism/providers/transport";
 import { applyKimiAnthropicCacheControl } from "./cache.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(/\/$/, "");
+    const baseUrl = (options.baseUrl ?? "https://api.kimi.com/coding").replace(/\/+$/, "");
     return {
         id,
         async *generate(request) {
@@ -32,7 +32,7 @@ export function createKimiCodingProvider(options = {}) {
                     signal: request.signal,
                 });
                 if (!response.ok) {
-                    return yield providerError(new Error(`Kimi request failed: ${response.status} ${await readBoundedResponseText(response, { secrets })}`), secrets);
+                    return yield providerError(httpStatusError("Kimi request failed", response, await readBoundedResponseText(response, { secrets })), secrets);
                 }
                 if (!response.body)
                     return yield providerError(new Error("Kimi response had no body"), secrets);

package/package.json

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