@arnilo/prism-provider-kimi 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to @arnilo/prism-provider-kimi will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Added `LICENSE` (MIT) and `CHANGELOG.md`.
+- Added npm package metadata: `license`, `repository`, `bugs`, `homepage`,
+  `keywords`, and `sideEffects`.
+
+### Changed
+
+- `files` whitelist now explicitly excludes `dist/__tests__/` and
+  `dist/**/*.map` from published tarballs.
+- Made `prism` a required peer dependency; it is no longer optional.
+
+## [0.0.1] - 2026-06-22
+
+### Added
+
+- Initial release of @arnilo/prism-provider-kimi.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prism contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# @arnilo/prism-provider-kimi
+
+Kimi provider package for Prism.
+
+```ts
+import { createKimiProviderPackage } from "@arnilo/prism-provider-kimi";
+
+api.registerProviderPackage(createKimiProviderPackage({ kimiApiKey: "fake-kimi-key" }));
+```
+
+Exports:
+- `createKimiProviderPackage()`
+- `createKimiCodingProvider()`
+- `kimiCodingModels`
+- `moonshotKimiModels`
+- `defineKimiModel()`
+
+Security defaults:
+- No network calls during import, setup, build, or default tests.
+- 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`.

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { type CredentialValueSource, type ModelConfig, type ProviderPackage } from "@arnilo/prism";
+export interface KimiProviderPackageOptions {
+    readonly kimiApiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    readonly baseUrl?: string;
+    readonly id?: string;
+    readonly userAgent?: string;
+    readonly models?: readonly ModelConfig[];
+    readonly includeMoonshotModels?: boolean;
+    readonly moonshotModels?: readonly ModelConfig[];
+}
+export declare function createKimiProviderPackage(options?: KimiProviderPackageOptions): ProviderPackage;
+export { defineKimiModel, kimiCodingModels, moonshotKimiModels, type KimiModelConfig } from "./models.js";
+export { createKimiCodingProvider, kimiAnthropicBody, kimiAnthropicEvents, type KimiCodingProviderOptions } from "./provider.js";

package/dist/index.js

@@ -0,0 +1,23 @@
+import { defineProviderPackage } from "@arnilo/prism";
+import { kimiCodingModels, moonshotKimiModels } from "./models.js";
+import { createKimiCodingProvider } from "./provider.js";
+export function createKimiProviderPackage(options = {}) {
+    const providerId = options.id ?? "kimi-coding";
+    return defineProviderPackage({
+        name: "@arnilo/prism-provider-kimi",
+        description: "Kimi provider package for Prism.",
+        docs: { links: ["docs/providers/kimi.md"] },
+        setup(api) {
+            api.registerProvider(createKimiCodingProvider({ ...options, id: providerId, apiKey: options.kimiApiKey }));
+            for (const model of options.models ?? kimiCodingModels)
+                api.registerModel({ ...model, provider: providerId });
+            if (options.includeMoonshotModels)
+                for (const model of options.moonshotModels ?? moonshotKimiModels)
+                    api.registerModel(model);
+            api.registerAuthMethod({ kind: "api_key", provider: providerId, credentialName: "apiKey" });
+        },
+    });
+}
+export { defineKimiModel, kimiCodingModels, moonshotKimiModels } from "./models.js";
+export { createKimiCodingProvider, kimiAnthropicBody, kimiAnthropicEvents } from "./provider.js";
+//# sourceMappingURL=index.js.map

package/dist/models.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject, ModelConfig } from "@arnilo/prism";
+export interface KimiModelConfig extends Omit<ModelConfig, "provider" | "compat"> {
+    readonly provider?: "kimi-coding" | "moonshot";
+    readonly compat?: JsonObject & {
+        readonly route?: "anthropic" | "openai";
+        readonly preserveThinking?: boolean;
+    };
+}
+export declare function defineKimiModel(config: KimiModelConfig): ModelConfig;
+export declare const kimiCodingModels: readonly [ModelConfig];
+export declare const moonshotKimiModels: readonly [ModelConfig];

package/dist/models.js

@@ -0,0 +1,22 @@
+export function defineKimiModel(config) {
+    return { ...config, provider: config.provider ?? "kimi-coding", capabilities: { input: ["text"], output: ["text"], reasoning: true, tools: true, streaming: true, ...config.capabilities } };
+}
+export const kimiCodingModels = [
+    defineKimiModel({
+        provider: "kimi-coding",
+        model: "kimi-k2.7-code",
+        displayName: "Kimi K2.7 Code",
+        limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
+        compat: { route: "anthropic", preserveThinking: true },
+    }),
+];
+export const moonshotKimiModels = [
+    defineKimiModel({
+        provider: "moonshot",
+        model: "kimi-k2.7-code-preview",
+        displayName: "Kimi K2.7 Code Preview",
+        limits: { contextWindow: 256_000, maxOutputTokens: 64_000 },
+        compat: { route: "openai", preserveThinking: true },
+    }),
+];
+//# sourceMappingURL=models.js.map

package/dist/provider.d.ts

@@ -0,0 +1,11 @@
+import type { AIProvider, CredentialValueSource, JsonObject, ProviderEvent, ProviderRequest } from "@arnilo/prism";
+export interface KimiCodingProviderOptions {
+    readonly id?: string;
+    readonly baseUrl?: string;
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    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>;

package/dist/provider.js

@@ -0,0 +1,158 @@
+import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent } from "@arnilo/prism";
+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(/\/$/, "");
+    return {
+        id,
+        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];
+            try {
+                const response = await (options.fetch ?? fetch)(`${baseUrl}/messages`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        "user-agent": options.userAgent ?? "KimiCLI/1.5",
+                        ...request.options?.headers,
+                        ...(token ? { authorization: `Bearer ${token}` } : {}),
+                    },
+                    body: JSON.stringify(kimiAnthropicBody(request)),
+                    signal: request.signal,
+                });
+                if (!response.ok)
+                    return yield providerError(new Error(`Kimi request failed: ${response.status} ${await safeText(response)}`), secrets);
+                if (!response.body)
+                    return yield providerError(new Error("Kimi response had no body"), secrets);
+                yield* kimiAnthropicEvents(response.body);
+            }
+            catch (error) {
+                yield providerError(error, secrets);
+            }
+        },
+    };
+}
+export function kimiAnthropicBody(request) {
+    const preserveThinking = request.model.compat?.preserveThinking === true;
+    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,
+        tools: request.tools?.map(toTool),
+        stream: true,
+        max_tokens: request.model.limits?.maxOutputTokens ?? 4096,
+        ...request.model.parameters,
+        ...request.options?.compat,
+        ...request.options?.extra,
+    });
+}
+export async function* kimiAnthropicEvents(body) {
+    const blocks = new Map();
+    let usage;
+    for await (const data of readSseData(body)) {
+        if (data === "[DONE]")
+            break;
+        const event = JSON.parse(data);
+        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_delta") {
+            const delta = event.delta;
+            if (delta?.type === "text_delta" && delta.text)
+                yield providerTextDelta(delta.text);
+            if ((delta?.type === "thinking_delta" || delta?.type === "reasoning_delta") && (delta.thinking ?? delta.reasoning))
+                yield providerThinkingDelta(delta.thinking ?? delta.reasoning ?? "");
+            if (delta?.type === "input_json_delta") {
+                const index = event.index ?? 0;
+                const current = blocks.get(index) ?? { argumentsText: "" };
+                current.argumentsText += delta.partial_json ?? "";
+                blocks.set(index, current);
+                yield providerToolCallDelta({ index, id: current.id, name: current.name, argumentsText: delta.partial_json });
+            }
+        }
+        usage = toUsage(event.message?.usage ?? event.usage) ?? usage;
+        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)));
+    yield providerDone(usage);
+}
+function toMessage(message, capabilities = {}, preserveThinking = false) {
+    if (message.role === "tool") {
+        const result = message.content.find((part) => part.type === "tool_result");
+        return {
+            role: "user",
+            content: [{
+                    type: "tool_result",
+                    tool_use_id: result?.toolCallId ?? "",
+                    content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
+                }],
+        };
+    }
+    const content = [];
+    for (const part of message.content) {
+        if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+        }
+        else if (part.type === "thinking") {
+            if (preserveThinking) {
+                content.push(part.signature ? { type: "thinking", thinking: part.text, signature: part.signature } : { type: "thinking", thinking: part.text });
+            }
+            else {
+                content.push({ type: "text", text: part.text });
+            }
+        }
+        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 ?? "" };
+            content.push({ type: "image", source });
+        }
+        else if (part.type === "tool_call") {
+            content.push({ type: "tool_use", id: part.id, name: part.name, input: part.arguments });
+        }
+        else if (part.type === "tool_result") {
+            throw new Error("Kimi tool_result blocks must appear in role=tool messages");
+        }
+    }
+    return { role: message.role === "assistant" ? "assistant" : "user", content: content.length > 0 ? content : [{ type: "text", text: "" }] };
+}
+function toTool(tool) {
+    return clean({ name: tool.name, description: tool.description, input_schema: tool.parameters ?? { type: "object" } });
+}
+function text(message, preserveThinking = false) {
+    return message.content.map((part) => {
+        if (part.type === "text")
+            return part.text;
+        if (part.type === "thinking")
+            return preserveThinking ? part.text : part.text;
+        return "";
+    }).join("");
+}
+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/dist/sse.d.ts

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

package/dist/sse.js

@@ -0,0 +1,24 @@
+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

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@arnilo/prism-provider-kimi",
+  "version": "0.0.1",
+  "description": "Kimi provider package for Prism.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "!dist/**/*.map",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test dist/__tests__/*.test.js",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "peerDependencies": {
+    "@arnilo/prism": "0.0.1"
+  },
+  "devDependencies": {
+    "@arnilo/prism": "file:../.."
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ashiqrniloy/prism.git",
+    "directory": "packages/provider-kimi"
+  },
+  "bugs": {
+    "url": "https://github.com/ashiqrniloy/prism/issues"
+  },
+  "homepage": "https://github.com/ashiqrniloy/prism/tree/main/packages/provider-kimi#readme",
+  "keywords": [
+    "prism",
+    "provider",
+    "kimi",
+    "agent",
+    "llm"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}