pi-provider-kimi-code 0.5.1 → 0.6.1

package/src/device.ts

@@ -2,6 +2,7 @@
 // headers, and the cross-platform device-model string. Pure helpers live near
 // the side-effecting one-shots (file IO, exec) they support.
 
+import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
@@ -96,11 +97,24 @@ export function computeDeviceModel(input: DeviceModelInput): string {
   return `${system} ${arch}`.trim();
 }
 
+function macOsProductVersion(): string | undefined {
+  try {
+    const version = execFileSync("/usr/bin/sw_vers", ["-productVersion"], {
+      encoding: "utf-8",
+      timeout: 1000,
+    }).trim();
+    return version.length > 0 ? version : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 function getDeviceModel(): string {
   return computeDeviceModel({
     platform: process.platform,
     release: os.release(),
     arch: os.machine() || process.arch,
+    macVersion: process.platform === "darwin" ? macOsProductVersion() : undefined,
   });
 }
 

package/src/models.ts

@@ -1,10 +1,10 @@
 // Model identity: discovery against the server's /v1/models endpoint, plus the
-// extras-merging helpers used by both the OAuth modifyModels hook and the
-// `KIMI_MODEL_*` env-override path.
+// extras-merging helpers used by both registration and the OAuth modifyModels hook.
 
 import type { Api, Model, OAuthCredentials } from "@earendil-works/pi-ai";
+import type { KimiInputModality, KimiResolvedModelConfig, ModelConfig } from "./config.ts";
 
-import { getBaseUrl } from "./constants.ts";
+import { type KimiWireProtocol, getBaseUrl } from "./constants.ts";
 import { getCommonHeaders } from "./device.ts";
 
 export interface KimiOAuthExtras {
@@ -13,16 +13,95 @@ export interface KimiOAuthExtras {
   contextLength?: number;
   supportsReasoning?: boolean;
   supportsImageIn?: boolean;
+  supportsVideoIn?: boolean;
+  supportsThinkingType?: "only" | "no" | "both";
 }
 
 export type KimiOAuthCredentials = OAuthCredentials & KimiOAuthExtras;
 
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
+
+export interface DiscoverKimiModelMetadataOptions {
+  timeoutMs?: number;
+}
+
+function mergeInputModalities(
+  input: readonly KimiInputModality[],
+  extras: Partial<Pick<KimiOAuthExtras, "supportsImageIn" | "supportsVideoIn">>,
+): KimiInputModality[] {
+  const next = new Set<KimiInputModality>(input);
+  next.add("text");
+  if (typeof extras.supportsImageIn === "boolean") {
+    if (extras.supportsImageIn) next.add("image");
+    else next.delete("image");
+  }
+  if (typeof extras.supportsVideoIn === "boolean") {
+    if (extras.supportsVideoIn) next.add("video");
+    else next.delete("video");
+  }
+  return (["text", "image", "video"] as const).filter((modality) => next.has(modality));
+}
+
+// Pricing per million tokens in USD (CNY converted at ~7.25).
+// Source: https://platform.kimi.com/docs/pricing/chat-k27-code
+const COST_STANDARD = { input: 0.897, output: 3.724, cacheRead: 0.179, cacheWrite: 0.897 };
+const COST_HIGH_SPEED = { input: 1.793, output: 7.448, cacheRead: 0.359, cacheWrite: 1.793 };
+
+function resolveModelCost(modelDisplay: string | undefined): {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+} {
+  if (modelDisplay && /high\s*speed/i.test(modelDisplay)) return COST_HIGH_SPEED;
+  return COST_STANDARD;
+}
+
+export function buildKimiModelFromConfig(config: ModelConfig): Model<Api> {
+  return {
+    id: "kimi-for-coding",
+    name: "Kimi for Coding",
+    reasoning: config.reasoning,
+    input: [...config.input] as unknown as ("text" | "image" | "video")[],
+    cost: { ...COST_STANDARD },
+    contextWindow: config.contextWindow,
+    maxTokens: config.maxTokens,
+  } as Model<Api>;
+}
+
+export function resolveKimiModelConfig(
+  config: ModelConfig,
+  extras: Partial<KimiOAuthExtras>,
+): KimiResolvedModelConfig {
+  const resolved: KimiResolvedModelConfig = { ...config, input: [...config.input] };
+  if (typeof extras.contextLength === "number" && extras.contextLength > 0) {
+    resolved.contextWindow = extras.contextLength;
+  }
+  if (typeof extras.supportsThinkingType === "string") {
+    resolved.supportsThinkingType = extras.supportsThinkingType;
+    resolved.reasoning = extras.supportsThinkingType !== "no";
+  } else if (typeof extras.supportsReasoning === "boolean") {
+    resolved.reasoning = extras.supportsReasoning;
+  }
+  if (typeof extras.supportsImageIn === "boolean" || typeof extras.supportsVideoIn === "boolean") {
+    resolved.input = mergeInputModalities(resolved.input, extras);
+  }
+  return resolved;
+}
+
 interface KimiServerModel {
   id?: unknown;
   display_name?: unknown;
   context_length?: unknown;
   supports_reasoning?: unknown;
   supports_image_in?: unknown;
+  supports_video_in?: unknown;
+  supports_thinking_type?: unknown;
+}
+
+function parseSupportsThinkingType(value: unknown): "only" | "no" | "both" | undefined {
+  if (value === "only" || value === "no" || value === "both") return value;
+  return undefined;
 }
 
 export function buildModelsUrl(baseUrl: string): string {
@@ -30,14 +109,23 @@ export function buildModelsUrl(baseUrl: string): string {
   return base.endsWith("/v1") ? `${base}/models` : `${base}/v1/models`;
 }
 
-function getModelsUrl(): string {
-  return buildModelsUrl(getBaseUrl());
+function getModelsUrl(protocol?: KimiWireProtocol): string {
+  return buildModelsUrl(getBaseUrl(protocol));
 }
 
-export async function discoverKimiModelMetadata(accessToken: string): Promise<KimiOAuthExtras> {
+export async function discoverKimiModelMetadata(
+  accessToken: string,
+  protocol?: KimiWireProtocol,
+  options: DiscoverKimiModelMetadataOptions = {},
+): Promise<KimiOAuthExtras> {
   if (!accessToken) return {};
+  const timeoutMs = options.timeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timeout =
+    timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs).unref() : undefined;
   try {
-    const response = await fetch(getModelsUrl(), {
+    const response = await fetch(getModelsUrl(protocol), {
+      signal: controller.signal,
       headers: {
         ...getCommonHeaders(),
         Authorization: `Bearer ${accessToken}`,
@@ -47,23 +135,30 @@ export async function discoverKimiModelMetadata(accessToken: string): Promise<Ki
     if (!response.ok) return {};
     const json = (await response.json()) as { data?: unknown };
     const list = Array.isArray(json.data) ? (json.data as KimiServerModel[]) : [];
-    const preferred =
-      list.find((m) => typeof m.id === "string" && m.id === "kimi-for-coding") ?? list[0];
+    const preferred = list.find((m) => typeof m.id === "string" && m.id === "kimi-for-coding");
     if (!preferred || typeof preferred.id !== "string") return {};
     const extras: KimiOAuthExtras = { wireModelId: preferred.id };
     if (typeof preferred.display_name === "string") extras.modelDisplay = preferred.display_name;
     if (typeof preferred.context_length === "number" && preferred.context_length > 0) {
       extras.contextLength = preferred.context_length;
     }
-    if (typeof preferred.supports_reasoning === "boolean") {
+    const thinkingType = parseSupportsThinkingType(preferred.supports_thinking_type);
+    if (thinkingType) {
+      extras.supportsThinkingType = thinkingType;
+    } else if (typeof preferred.supports_reasoning === "boolean") {
       extras.supportsReasoning = preferred.supports_reasoning;
     }
     if (typeof preferred.supports_image_in === "boolean") {
       extras.supportsImageIn = preferred.supports_image_in;
     }
+    if (typeof preferred.supports_video_in === "boolean") {
+      extras.supportsVideoIn = preferred.supports_video_in;
+    }
     return extras;
   } catch {
     return {};
+  } finally {
+    if (timeout) clearTimeout(timeout);
   }
 }
 
@@ -71,9 +166,11 @@ export function applyKimiOAuthExtrasToModel(
   model: Model<Api>,
   extras: KimiOAuthExtras,
 ): Model<Api> {
-  const next: Model<Api> & { wireModelId?: string } = { ...model };
+  const next: Model<Api> & { wireModelId?: string; supportsThinkingType?: "only" | "no" | "both" } =
+    { ...model };
   if (typeof extras.modelDisplay === "string" && extras.modelDisplay) {
     next.name = extras.modelDisplay;
+    next.cost = resolveModelCost(extras.modelDisplay);
   }
   if (typeof extras.contextLength === "number" && extras.contextLength > 0) {
     next.contextWindow = extras.contextLength;
@@ -81,49 +178,16 @@ export function applyKimiOAuthExtrasToModel(
   if (typeof extras.wireModelId === "string" && extras.wireModelId) {
     next.wireModelId = extras.wireModelId;
   }
-  if (typeof extras.supportsReasoning === "boolean") {
+  if (typeof extras.supportsThinkingType === "string") {
+    next.reasoning = extras.supportsThinkingType !== "no";
+    next.supportsThinkingType = extras.supportsThinkingType;
+  } else if (typeof extras.supportsReasoning === "boolean") {
     next.reasoning = extras.supportsReasoning;
+    next.supportsThinkingType = undefined;
   }
-  if (typeof extras.supportsImageIn === "boolean") {
-    const input = ["text"];
-    if (extras.supportsImageIn) input.push("image");
+  if (typeof extras.supportsImageIn === "boolean" || typeof extras.supportsVideoIn === "boolean") {
+    const input = mergeInputModalities(next.input as KimiInputModality[], extras);
     (next as unknown as { input: string[] }).input = input;
   }
   return next;
 }
-
-function parseKimiModelCapabilities(value: string | undefined): KimiOAuthExtras | null {
-  if (!value) return null;
-  const caps = new Set(
-    value
-      .split(",")
-      .map((cap) => cap.trim().toLowerCase())
-      .filter(Boolean),
-  );
-  return {
-    supportsReasoning: caps.has("thinking") || caps.has("always_thinking"),
-    supportsImageIn: caps.has("image_in"),
-  };
-}
-
-export function applyKimiEnvOverridesToModel(model: Model<Api>): Model<Api> {
-  const extras: KimiOAuthExtras = {};
-  const modelName = process.env.KIMI_MODEL_NAME?.trim();
-  if (modelName) {
-    extras.wireModelId = modelName;
-    extras.modelDisplay = modelName;
-  }
-
-  const maxContextSize = process.env.KIMI_MODEL_MAX_CONTEXT_SIZE?.trim();
-  if (maxContextSize) {
-    const parsed = parseInt(maxContextSize, 10);
-    if (Number.isFinite(parsed) && parsed > 0) {
-      extras.contextLength = parsed;
-    }
-  }
-
-  const capabilities = parseKimiModelCapabilities(process.env.KIMI_MODEL_CAPABILITIES);
-  if (capabilities) Object.assign(extras, capabilities);
-
-  return applyKimiOAuthExtrasToModel(model, extras);
-}

package/src/payload.ts

@@ -3,9 +3,11 @@
 // and the top-level applyKimiPayloadMutations that orchestrates them.
 
 import type { CacheRetention, ThinkingLevel } from "@earendil-works/pi-ai";
+import type { KimiResolvedModelConfig, ModelReasoningEntry } from "./config.ts";
 
 import { getBaseUrl } from "./constants.ts";
 import { getCommonHeaders } from "./device.ts";
+import { optimizeToolSchemas } from "./schema-dedup.ts";
 
 // =============================================================================
 // Shared types + small utilities
@@ -16,12 +18,6 @@ const DEFAULT_KIMI_INLINE_UPLOAD_THRESHOLD_BYTES = 1 * 1024 * 1024;
 export type JsonRecord = Record<string, unknown>;
 export type Uploader = (mimeType: string, data: string) => Promise<string | null>;
 
-export interface KimiEnvOverrides {
-  temperature?: number;
-  topP?: number;
-  maxCompletionTokens?: number;
-}
-
 export function resolveCacheRetention(value?: CacheRetention): CacheRetention {
   if (value === "none" || value === "short" || value === "long") return value;
   const envRetention = process.env.PI_CACHE_RETENTION;
@@ -37,21 +33,28 @@ export interface KimiPayloadContext {
   cacheKey?: string;
   cacheRetention: CacheRetention;
   reasoning?: ThinkingLevel;
-  thinkingKeep?: string;
-  envOverrides: KimiEnvOverrides;
+  modelConfig: KimiResolvedModelConfig;
 }
 
 export function isRecord(value: unknown): value is JsonRecord {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function mapThinkingLevel(level?: string): { effort: string | null; enabled: boolean } | undefined {
-  if (!level) return undefined;
-  if (level === "none" || level === "off") return { effort: null, enabled: false };
-  if (level === "minimal" || level === "low") return { effort: "low", enabled: true };
-  if (level === "medium") return { effort: "medium", enabled: true };
-  if (level === "high" || level === "xhigh") return { effort: "high", enabled: true };
-  return undefined;
+export function resolveReasoningForLevel(
+  level: string,
+  config: KimiResolvedModelConfig,
+): ModelReasoningEntry | undefined {
+  return config.reasoningMap[level];
+}
+
+function resolveThinkingLevel(ctx: KimiPayloadContext): ThinkingLevel | undefined {
+  if (ctx.modelConfig.supportsThinkingType === "no") return undefined;
+  if (ctx.modelConfig.supportsThinkingType === "only") {
+    if (!ctx.reasoning) return "low";
+    const mapped = resolveReasoningForLevel(ctx.reasoning, ctx.modelConfig);
+    if (mapped && !mapped.enabled) return "low";
+  }
+  return ctx.reasoning;
 }
 
 function parseInlineUploadThreshold(raw: string | undefined): number {
@@ -81,17 +84,6 @@ function getUploadFilename(mimeType: string): string {
   return map[mimeType] ?? "upload.bin";
 }
 
-export function readEnvOverrides(): KimiEnvOverrides {
-  const out: KimiEnvOverrides = {};
-  const temp = process.env.KIMI_MODEL_TEMPERATURE;
-  if (temp) out.temperature = parseFloat(temp);
-  const topP = process.env.KIMI_MODEL_TOP_P;
-  if (topP) out.topP = parseFloat(topP);
-  const maxCompletionTokens = process.env.KIMI_MODEL_MAX_COMPLETION_TOKENS;
-  if (maxCompletionTokens) out.maxCompletionTokens = parseInt(maxCompletionTokens, 10);
-  return out;
-}
-
 // =============================================================================
 // File upload (I/O edge)
 // =============================================================================
@@ -100,10 +92,12 @@ export async function uploadKimiFile(
   apiKey: string,
   mimeType: string,
   data: string,
+  thresholdBytes?: number,
 ): Promise<string | null> {
   const buffer = Buffer.from(data, "base64");
   if (!mimeType.startsWith("image/")) return null;
-  const threshold = parseInlineUploadThreshold(process.env.KIMI_CODE_UPLOAD_THRESHOLD_BYTES);
+  const threshold =
+    thresholdBytes ?? parseInlineUploadThreshold(process.env.KIMI_CODE_UPLOAD_THRESHOLD_BYTES);
   if (buffer.length <= threshold) return null;
 
   const filename = getUploadFilename(mimeType);
@@ -406,6 +400,9 @@ export async function applyKimiPayloadMutations(
     normalizeOpenAIAssistantToolCalls(payload);
     normalizeOpenAIToolSchemas(payload);
   }
+  if (Array.isArray(payload.tools)) {
+    payload.tools = optimizeToolSchemas(payload.tools);
+  }
 
   // 3. prompt_cache_key injection. Respect any key already on the payload,
   //    otherwise fall back to the caller-provided cacheKey (sessionId or
@@ -420,35 +417,81 @@ export async function applyKimiPayloadMutations(
     if (resolved) payload.prompt_cache_key = resolved;
   }
 
-  // 4. Normalize deprecated max_tokens and apply env-level hyperparameter
-  //    overrides (pre-parsed into numbers by caller).
-  if (payload.max_completion_tokens === undefined && typeof payload.max_tokens === "number") {
-    payload.max_completion_tokens = payload.max_tokens;
+  // 4. Request usage stats on streaming responses (OpenAI only —
+  //    Anthropic /messages does not support stream_options).
+  if (ctx.api === "openai-completions" && payload.stream === true) {
+    payload.stream_options = isRecord(payload.stream_options)
+      ? { ...(payload.stream_options as JsonRecord), include_usage: true }
+      : { include_usage: true };
+  }
+
+  // 5. Normalize deprecated max_tokens (OpenAI path only — Anthropic
+  //    /messages uses max_tokens natively).
+  if (ctx.api === "openai-completions") {
+    if (payload.max_completion_tokens === undefined && typeof payload.max_tokens === "number") {
+      payload.max_completion_tokens = payload.max_tokens;
+    }
+    delete payload.max_tokens;
+  }
+
+  const generation = ctx.modelConfig.generation;
+  if (generation.temperature !== undefined) payload.temperature = generation.temperature;
+  if (generation.topP !== undefined) payload.top_p = generation.topP;
+  if (generation.maxCompletionTokens !== undefined) {
+    payload.max_completion_tokens = generation.maxCompletionTokens;
   }
-  delete payload.max_tokens;
 
-  const { temperature, topP, maxCompletionTokens } = ctx.envOverrides;
-  if (temperature !== undefined) payload.temperature = temperature;
-  if (topP !== undefined) payload.top_p = topP;
-  if (maxCompletionTokens !== undefined) {
-    payload.max_completion_tokens = maxCompletionTokens;
+  // 5. Spread extra_body into top-level payload before reasoning mapping,
+  //    matching upstream (Kimi expects thinking etc. at the root).
+  if (isRecord(payload.extra_body)) {
+    const extraBody = payload.extra_body as JsonRecord;
+    delete payload.extra_body;
+    for (const [key, value] of Object.entries(extraBody)) {
+      if (payload[key] === undefined) {
+        payload[key] = value;
+      }
+    }
   }
 
-  // 5. Reasoning effort mapping.
-  if (ctx.reasoning) {
-    const mapped = mapThinkingLevel(ctx.reasoning);
+  // 6. Reasoning effort mapping. Merges into any existing top-level thinking
+  //    field (which may have come from extra_body above).
+  const resolvedReasoning = resolveThinkingLevel(ctx);
+  if (resolvedReasoning) {
+    const mapped = resolveReasoningForLevel(resolvedReasoning, ctx.modelConfig);
     if (mapped) {
-      payload.reasoning_effort = mapped.effort;
-      const extraBody = isRecord(payload.extra_body) ? payload.extra_body : {};
-      const oldThinking = isRecord(extraBody.thinking) ? extraBody.thinking : {};
-      extraBody.thinking = {
+      if (mapped.effort !== null) {
+        payload.reasoning_effort = mapped.effort;
+      } else {
+        delete payload.reasoning_effort;
+      }
+      const oldThinking = isRecord(payload.thinking) ? payload.thinking : {};
+      payload.thinking = {
         ...oldThinking,
         type: mapped.enabled ? "enabled" : "disabled",
       };
-      if (mapped.enabled && ctx.thinkingKeep) {
-        (extraBody.thinking as JsonRecord).keep = ctx.thinkingKeep;
+      if (mapped.enabled && ctx.modelConfig.thinkingKeep) {
+        (payload.thinking as JsonRecord).keep = ctx.modelConfig.thinkingKeep;
       }
-      payload.extra_body = extraBody;
+    }
+  }
+
+  // 7. K2.7 Code API constraints: the server rejects non-default values for
+  //    temperature (must be 1.0) and top_p (must be 0.95), and tool_choice
+  //    "required" / function-specific when thinking is enabled (always-on).
+  if (payload.temperature !== undefined && payload.temperature !== 1) {
+    delete payload.temperature;
+  }
+  if (payload.top_p !== undefined && payload.top_p !== 0.95) {
+    delete payload.top_p;
+  }
+  if (payload.tool_choice !== undefined) {
+    const tc = payload.tool_choice;
+    const isAllowed =
+      tc === "auto" ||
+      tc === "none" ||
+      (isRecord(tc) && (tc.type === "auto" || tc.type === "none"));
+    if (!isAllowed) {
+      payload.tool_choice = isRecord(tc) ? { type: "auto" } : "auto";
     }
   }
 }