pi-provider-kimi-code 0.3.1 → 0.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.3.1",
-  "description": "Pi extension for Kimi Code — reuse your Kimi Code Plan in pi-coding-agent (K2.6, K2.5)",
+  "version": "0.4.0",
+  "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
   "keywords": [
     "pi-package",
     "pi-extension",
@@ -36,6 +36,7 @@
   "author": "Leechael",
   "files": [
     "index.ts",
+    "src",
     "package.json",
     "README.md"
   ],
@@ -43,20 +44,23 @@
   "scripts": {
     "clean": "echo 'nothing to clean'",
     "build": "echo 'nothing to build'",
-    "check": "echo 'nothing to check'",
+    "check": "tsc --noEmit",
+    "test": "node --test tests/*.test.ts",
     "lint": "oxlint .",
     "format": "oxfmt . --write",
     "format:check": "oxfmt . --check",
     "pre-commit": "prek run"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-ai": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*"
   },
   "devDependencies": {
     "@j178/prek": "^0.3.8",
+    "@types/node": "^24.0.0",
     "oxfmt": "^0.44.0",
-    "oxlint": "^1.59.0"
+    "oxlint": "^1.59.0",
+    "typescript": "^5.9.0"
   },
   "pi": {
     "extensions": [

package/src/config.ts

@@ -0,0 +1,151 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface KimiCodeConfig {
+  tools: {
+    moonshot_search: { enabled: boolean; default_collapsed: boolean };
+    moonshot_fetch: { enabled: boolean; default_collapsed: boolean };
+  };
+}
+
+export interface LoadKimiCodeConfigOptions {
+  cwd: string;
+  home: string;
+}
+
+export const DEFAULT_KIMI_CODE_CONFIG: KimiCodeConfig = {
+  tools: {
+    moonshot_search: { enabled: false, default_collapsed: true },
+    moonshot_fetch: { enabled: false, default_collapsed: true },
+  },
+};
+
+export function getGlobalKimiCodeConfigPath(home: string): string {
+  return join(home, ".pi", "pi-provider-kimi-code.json");
+}
+
+export function getProjectKimiCodeConfigPath(cwd: string): string {
+  return join(cwd, ".pi", "pi-provider-kimi-code.json");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readConfigFile(path: string): Record<string, unknown> {
+  try {
+    if (!existsSync(path)) return {};
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    return isRecord(parsed) ? parsed : {};
+  } catch (error) {
+    console.error(`[kimi-coding] failed to read config file ${path}:`, error);
+    return {};
+  }
+}
+
+function readConfigFileQuiet(path: string): Record<string, unknown> {
+  try {
+    if (!existsSync(path)) return {};
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function mergeConfig(
+  base: Record<string, unknown>,
+  override: Record<string, unknown>,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const current = result[key];
+    if (isRecord(current) && isRecord(value)) {
+      result[key] = mergeConfig(current, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function readEnabled(config: Record<string, unknown>, toolName: string): boolean {
+  const tools = config.tools;
+  if (!isRecord(tools)) return false;
+  const tool = tools[toolName];
+  if (!isRecord(tool)) return false;
+  return tool.enabled === true;
+}
+
+function readDefaultCollapsed(config: Record<string, unknown>, toolName: string): boolean {
+  const tools = config.tools;
+  if (!isRecord(tools)) return true;
+  const tool = tools[toolName];
+  if (!isRecord(tool)) return true;
+  return tool.default_collapsed !== false;
+}
+
+export function loadKimiCodeConfig(options: LoadKimiCodeConfigOptions): KimiCodeConfig {
+  const globalConfig = readConfigFile(getGlobalKimiCodeConfigPath(options.home));
+  const projectConfig = readConfigFile(getProjectKimiCodeConfigPath(options.cwd));
+  const merged = mergeConfig(globalConfig, projectConfig);
+
+  return {
+    tools: {
+      moonshot_search: {
+        enabled: readEnabled(merged, "moonshot_search"),
+        default_collapsed: readDefaultCollapsed(merged, "moonshot_search"),
+      },
+      moonshot_fetch: {
+        enabled: readEnabled(merged, "moonshot_fetch"),
+        default_collapsed: readDefaultCollapsed(merged, "moonshot_fetch"),
+      },
+    },
+  };
+}
+
+export function loadProjectKimiCodeConfig(cwd: string): KimiCodeConfig {
+  return loadKimiCodeConfigFile(getProjectKimiCodeConfigPath(cwd));
+}
+
+export function loadHomeKimiCodeConfig(home: string): KimiCodeConfig {
+  return loadKimiCodeConfigFile(getGlobalKimiCodeConfigPath(home));
+}
+
+function loadKimiCodeConfigFile(path: string): KimiCodeConfig {
+  const projectConfig = readConfigFileQuiet(path);
+  return {
+    tools: {
+      moonshot_search: {
+        enabled: readEnabled(projectConfig, "moonshot_search"),
+        default_collapsed: readDefaultCollapsed(projectConfig, "moonshot_search"),
+      },
+      moonshot_fetch: {
+        enabled: readEnabled(projectConfig, "moonshot_fetch"),
+        default_collapsed: readDefaultCollapsed(projectConfig, "moonshot_fetch"),
+      },
+    },
+  };
+}
+
+export function saveProjectKimiCodeConfig(cwd: string, config: KimiCodeConfig): void {
+  saveKimiCodeConfigFile(getProjectKimiCodeConfigPath(cwd), config);
+}
+
+export function saveHomeKimiCodeConfig(home: string, config: KimiCodeConfig): void {
+  saveKimiCodeConfigFile(getGlobalKimiCodeConfigPath(home), config);
+}
+
+function saveKimiCodeConfigFile(path: string, config: KimiCodeConfig): void {
+  const raw = readConfigFileQuiet(path);
+  const next = {
+    ...raw,
+    tools: {
+      ...(isRecord(raw.tools) ? raw.tools : {}),
+      moonshot_search: { ...config.tools.moonshot_search },
+      moonshot_fetch: { ...config.tools.moonshot_fetch },
+    },
+  };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}

package/src/constants.ts

@@ -0,0 +1,48 @@
+// Module-level constants and env-driven configuration shared across the
+// provider's modules. Anything env-dependent that we read once at module load
+// time lives here; helpers that need to be evaluated per request go in env.ts
+// (not yet split).
+
+import os from "node:os";
+import { join } from "node:path";
+
+export const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
+export const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
+
+// KIMI_CODE_PROTOCOL supports two values: "openai" (default) and "anthropic".
+export const IS_OPENAI_PROTOCOL = process.env.KIMI_CODE_PROTOCOL !== "anthropic";
+
+export const PROTOCOL = IS_OPENAI_PROTOCOL ? "openai-completions" : "anthropic-messages";
+
+// Use a custom api identifier so this provider never conflicts with the
+// built-in "anthropic-messages" or "openai-completions" stream handlers.
+export const KIMI_API_TYPE = IS_OPENAI_PROTOCOL
+  ? "kimi-openai-completions"
+  : "kimi-anthropic-messages";
+
+export const DEFAULT_BASE_URL = IS_OPENAI_PROTOCOL
+  ? "https://api.kimi.com/coding/v1"
+  : "https://api.kimi.com/coding";
+
+export const KIMI_CLI_VERSION = "1.44.0";
+export const KIMI_CLI_USER_AGENT = `KimiCLI/${KIMI_CLI_VERSION}`;
+export const KIMI_PLATFORM = "kimi_cli";
+
+export const DEVICE_ID_PATH = join(os.homedir(), ".pi", "providers", "kimi-coding", "device_id");
+
+export const DEFAULT_KIMI_MODEL_INPUT = ["text", "image"] as const;
+
+export const RETRYABLE_REFRESH_STATUSES = new Set([429, 500, 502, 503, 504]);
+
+export const PROVIDER_ID = "kimi-coding";
+
+export function getOAuthHost(): string {
+  const value =
+    process.env.KIMI_CODE_OAUTH_HOST || process.env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST;
+  return value.trim() || DEFAULT_OAUTH_HOST;
+}
+
+export function getBaseUrl(): string {
+  const value = process.env.KIMI_CODE_BASE_URL || process.env.KIMI_BASE_URL || DEFAULT_BASE_URL;
+  return value.trim() || DEFAULT_BASE_URL;
+}

package/src/device.ts

@@ -0,0 +1,164 @@
+// Device identification: device-id persistence, kimi-cli-compatible request
+// headers, and the cross-platform device-model string. Pure helpers live near
+// the side-effecting one-shots (file IO, exec) they support.
+
+import { execSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import { dirname } from "node:path";
+
+import {
+  DEVICE_ID_PATH,
+  KIMI_CLI_USER_AGENT,
+  KIMI_CLI_VERSION,
+  KIMI_PLATFORM,
+} from "./constants.ts";
+
+function createDeviceId(): string {
+  return randomBytes(16).toString("hex");
+}
+
+function ensurePrivateFile(path: string): void {
+  try {
+    chmodSync(path, 0o600);
+  } catch {
+    // Ignore chmod failures on platforms/filesystems that do not support it.
+  }
+}
+
+function readPersistedDeviceId(): string | null {
+  try {
+    if (!existsSync(DEVICE_ID_PATH)) return null;
+    const deviceId = readFileSync(DEVICE_ID_PATH, "utf8").trim();
+    return deviceId || null;
+  } catch {
+    return null;
+  }
+}
+
+function persistDeviceId(deviceId: string): void {
+  try {
+    mkdirSync(dirname(DEVICE_ID_PATH), { recursive: true });
+    writeFileSync(DEVICE_ID_PATH, deviceId, "utf8");
+    ensurePrivateFile(DEVICE_ID_PATH);
+  } catch {
+    // Ignore persistence failures and fall back to the in-memory device id.
+  }
+}
+
+function getMacOSVersion(): string {
+  try {
+    return execSync("sw_vers -productVersion", { encoding: "utf8" }).trim();
+  } catch {
+    return os.release();
+  }
+}
+
+// Normalize Node's lower-case `process.platform` (`linux`, `freebsd`,
+// `sunos`...) to Python `platform.system()` casing used by upstream kimi-cli.
+const SYSTEM_NAME: Record<string, string> = {
+  aix: "AIX",
+  freebsd: "FreeBSD",
+  linux: "Linux",
+  openbsd: "OpenBSD",
+  sunos: "SunOS",
+};
+
+export interface DeviceModelInput {
+  platform: NodeJS.Platform;
+  release: string;
+  arch: string;
+  /** macOS productVersion (e.g. "15.2"). Required only on darwin. */
+  macVersion?: string;
+}
+
+// Pure function exposed for tests. Mirror of upstream kimi-cli's
+// `_device_model()` in `src/kimi_cli/auth/oauth.py`.
+export function computeDeviceModel(input: DeviceModelInput): string {
+  const { platform, release, arch, macVersion } = input;
+  if (platform === "darwin") {
+    const version = macVersion || release;
+    if (version && arch) return `macOS ${version} ${arch}`;
+    if (version) return `macOS ${version}`;
+    return `macOS ${arch}`.trim();
+  }
+  if (platform === "win32") {
+    // Only show the major release (e.g. "Windows 10", "Windows 11") to match
+    // the upstream behavior. Windows 11 still reports kernel version
+    // "10.0.xxxxx"; treat build ≥ 22000 as Windows 11.
+    const parts = release.split(".");
+    let label = parts[0];
+    if (label === "10" && parts.length >= 3) {
+      const build = parseInt(parts[2], 10);
+      if (!isNaN(build) && build >= 22000) {
+        label = "11";
+      }
+    }
+    if (label && arch) return `Windows ${label} ${arch}`;
+    if (label) return `Windows ${label}`;
+    return `Windows ${arch}`.trim();
+  }
+  const system = SYSTEM_NAME[platform] ?? platform;
+  if (release && arch) return `${system} ${release} ${arch}`;
+  if (release) return `${system} ${release}`;
+  return `${system} ${arch}`.trim();
+}
+
+function getDeviceModel(): string {
+  return computeDeviceModel({
+    platform: process.platform,
+    release: os.release(),
+    arch: os.machine() || process.arch,
+    macVersion: process.platform === "darwin" ? getMacOSVersion() : undefined,
+  });
+}
+
+export function getOsVersion(): string {
+  return os.version();
+}
+
+export function asciiHeaderValue(value: string, fallback = "unknown"): string {
+  const trimmed = value.trim();
+  /* oxlint-disable-next-line no-control-regex */
+  if (/^[\x00-\x7F]*$/.test(trimmed)) {
+    return trimmed;
+  }
+  /* oxlint-disable-next-line no-control-regex */
+  const sanitized = trimmed.replace(/[^\x00-\x7F]/g, "").trim();
+  return sanitized || fallback;
+}
+
+const DEVICE_MODEL = getDeviceModel();
+let DEVICE_ID: string | null = null;
+
+function getStableDeviceId(): string {
+  if (DEVICE_ID) {
+    return DEVICE_ID;
+  }
+
+  const persisted = readPersistedDeviceId();
+  if (persisted) {
+    DEVICE_ID = persisted;
+    return DEVICE_ID;
+  }
+
+  DEVICE_ID = createDeviceId();
+  persistDeviceId(DEVICE_ID);
+  return DEVICE_ID;
+}
+
+export function getCommonHeaders(): Record<string, string> {
+  const headers = {
+    "User-Agent": KIMI_CLI_USER_AGENT,
+    "X-Msh-Platform": KIMI_PLATFORM,
+    "X-Msh-Version": KIMI_CLI_VERSION,
+    "X-Msh-Device-Name": os.hostname(),
+    "X-Msh-Device-Model": DEVICE_MODEL,
+    "X-Msh-Os-Version": getOsVersion(),
+    "X-Msh-Device-Id": getStableDeviceId(),
+  };
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [key, asciiHeaderValue(value)]),
+  ) as Record<string, string>;
+}

package/src/models.ts

@@ -0,0 +1,129 @@
+// 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.
+
+import type { Api, Model, OAuthCredentials } from "@earendil-works/pi-ai";
+
+import { getBaseUrl } from "./constants.ts";
+import { getCommonHeaders } from "./device.ts";
+
+export interface KimiOAuthExtras {
+  wireModelId?: string;
+  modelDisplay?: string;
+  contextLength?: number;
+  supportsReasoning?: boolean;
+  supportsImageIn?: boolean;
+}
+
+export type KimiOAuthCredentials = OAuthCredentials & KimiOAuthExtras;
+
+interface KimiServerModel {
+  id?: unknown;
+  display_name?: unknown;
+  context_length?: unknown;
+  supports_reasoning?: unknown;
+  supports_image_in?: unknown;
+}
+
+export function buildModelsUrl(baseUrl: string): string {
+  const base = baseUrl.replace(/\/+$/, "");
+  return base.endsWith("/v1") ? `${base}/models` : `${base}/v1/models`;
+}
+
+function getModelsUrl(): string {
+  return buildModelsUrl(getBaseUrl());
+}
+
+export async function discoverKimiModelMetadata(accessToken: string): Promise<KimiOAuthExtras> {
+  if (!accessToken) return {};
+  try {
+    const response = await fetch(getModelsUrl(), {
+      headers: {
+        ...getCommonHeaders(),
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+      },
+    });
+    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];
+    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") {
+      extras.supportsReasoning = preferred.supports_reasoning;
+    }
+    if (typeof preferred.supports_image_in === "boolean") {
+      extras.supportsImageIn = preferred.supports_image_in;
+    }
+    return extras;
+  } catch {
+    return {};
+  }
+}
+
+export function applyKimiOAuthExtrasToModel(
+  model: Model<Api>,
+  extras: KimiOAuthExtras,
+): Model<Api> {
+  const next: Model<Api> & { wireModelId?: string } = { ...model };
+  if (typeof extras.modelDisplay === "string" && extras.modelDisplay) {
+    next.name = extras.modelDisplay;
+  }
+  if (typeof extras.contextLength === "number" && extras.contextLength > 0) {
+    next.contextWindow = extras.contextLength;
+  }
+  if (typeof extras.wireModelId === "string" && extras.wireModelId) {
+    next.wireModelId = extras.wireModelId;
+  }
+  if (typeof extras.supportsReasoning === "boolean") {
+    next.reasoning = extras.supportsReasoning;
+  }
+  if (typeof extras.supportsImageIn === "boolean") {
+    const input = ["text"];
+    if (extras.supportsImageIn) input.push("image");
+    (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);
+}