pi-provider-kimi-code 0.4.1 → 0.5.1

package/README.md

@@ -3,21 +3,6 @@
 [![npm](https://img.shields.io/npm/v/pi-provider-kimi-code)](https://www.npmjs.com/package/pi-provider-kimi-code)
 [![license](https://img.shields.io/npm/l/pi-provider-kimi-code)](./LICENSE)
 
----
-
-> [!CAUTION]
-> ## THIS PLUGIN IS NO LONGER MAINTAINED — DO NOT USE
->
-> **Why this project was abandoned:**
->
-> - **Account suspended by mistake.** Moonshot suspended the maintainer's account citing a policy violation that never occurred.
-> - **No explanation after reinstatement.** The account was eventually unblocked, but Moonshot provided no reason, no apology, and no clarification of what triggered the ban.
-> - **Discriminatory treatment of Chinese users.** Moonshot's platform shows a consistent pattern of treating Chinese-language users differently — stricter enforcement, opaque policies, and no recourse.
->
-> Building on top of a vendor that bans first and refuses to explain afterwards is not a foundation worth maintaining. **Use this code at your own risk. No issues will be triaged. No PRs will be merged. No releases will be cut.**
-
----
-
 **Use Kimi Code in Pi, with the Kimi parts handled.**
 
 Pi already has a basic `kimi-coding` provider. This extension is for the parts that start to matter once Kimi Code becomes part of your real Pi workflow: account login reuse, file uploads, measured cache behavior, live model metadata, and optional Moonshot search/fetch tools.

package/package.json

@@ -1,39 +1,39 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
   "keywords": [
-    "pi-package",
-    "pi-extension",
-    "pi-provider",
-    "pi",
-    "pi-coding-agent",
-    "pi-mono",
-    "coding-agent",
     "ai-provider",
-    "llm",
-    "llm-provider",
+    "coding-agent",
+    "device-code",
     "kimi",
-    "kimi-for-coding",
     "kimi-coder",
+    "kimi-for-coding",
     "kimi-k2",
-    "kimi-k2.6",
     "kimi-k2.5",
+    "kimi-k2.6",
+    "llm",
+    "llm-provider",
     "moonshot",
     "moonshotai",
     "oauth",
-    "device-code",
+    "pi",
+    "pi-coding-agent",
+    "pi-extension",
+    "pi-mono",
+    "pi-package",
+    "pi-provider",
     "subscription"
   ],
+  "bugs": {
+    "url": "https://github.com/Leechael/pi-provider-kimi-code/issues"
+  },
   "license": "MIT",
+  "author": "Leechael",
   "repository": {
     "type": "git",
     "url": "https://github.com/Leechael/pi-provider-kimi-code"
   },
-  "bugs": {
-    "url": "https://github.com/Leechael/pi-provider-kimi-code/issues"
-  },
-  "author": "Leechael",
   "files": [
     "index.ts",
     "src",
@@ -51,17 +51,19 @@
     "format:check": "oxfmt . --check",
     "pre-commit": "prek run"
   },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-ai": "*"
-  },
   "devDependencies": {
+    "@earendil-works/pi-ai": "^0.78.0",
+    "@earendil-works/pi-coding-agent": "^0.78.0",
     "@j178/prek": "^0.3.8",
     "@types/node": "^24.0.0",
     "oxfmt": "^0.44.0",
     "oxlint": "^1.59.0",
     "typescript": "^5.9.0"
   },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
   "pi": {
     "extensions": [
       "./index.ts"

package/src/constants.ts

@@ -24,11 +24,16 @@ 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 KIMI_CODE_VERSION = "0.6.0";
+export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_CODE_VERSION}`;
+export const KIMI_PLATFORM = "kimi_code_cli";
 
-export const DEVICE_ID_PATH = join(os.homedir(), ".pi", "providers", "kimi-coding", "device_id");
+export function getKimiCodeHome(): string {
+  const value = process.env.KIMI_CODE_HOME?.trim();
+  return value || join(os.homedir(), ".kimi-code");
+}
+
+export const DEVICE_ID_PATH = join(getKimiCodeHome(), "device_id");
 
 export const DEFAULT_KIMI_MODEL_INPUT = ["text", "image"] as const;
 

package/src/device.ts

@@ -1,8 +1,7 @@
-// Device identification: device-id persistence, kimi-cli-compatible request
+// Device identification: device-id persistence, Kimi Code-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";
@@ -10,8 +9,8 @@ import { dirname } from "node:path";
 
 import {
   DEVICE_ID_PATH,
-  KIMI_CLI_USER_AGENT,
-  KIMI_CLI_VERSION,
+  KIMI_CODE_USER_AGENT,
+  KIMI_CODE_VERSION,
   KIMI_PLATFORM,
 } from "./constants.ts";
 
@@ -47,16 +46,8 @@ function persistDeviceId(deviceId: string): void {
   }
 }
 
-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.
+// `sunos`...) to the canonical OS names used by Kimi Code identity headers.
 const SYSTEM_NAME: Record<string, string> = {
   aix: "AIX",
   freebsd: "FreeBSD",
@@ -73,8 +64,8 @@ export interface DeviceModelInput {
   macVersion?: string;
 }
 
-// Pure function exposed for tests. Mirror of upstream kimi-cli's
-// `_device_model()` in `src/kimi_cli/auth/oauth.py`.
+// Pure function exposed for tests. Mirrors upstream Kimi Code identity
+// formatting in `packages/oauth/src/identity.ts`.
 export function computeDeviceModel(input: DeviceModelInput): string {
   const { platform, release, arch, macVersion } = input;
   if (platform === "darwin") {
@@ -110,12 +101,11 @@ function getDeviceModel(): string {
     platform: process.platform,
     release: os.release(),
     arch: os.machine() || process.arch,
-    macVersion: process.platform === "darwin" ? getMacOSVersion() : undefined,
   });
 }
 
 export function getOsVersion(): string {
-  return os.version();
+  return os.release();
 }
 
 export function asciiHeaderValue(value: string, fallback = "unknown"): string {
@@ -150,9 +140,9 @@ function getStableDeviceId(): string {
 
 export function getCommonHeaders(): Record<string, string> {
   const headers = {
-    "User-Agent": KIMI_CLI_USER_AGENT,
+    "User-Agent": KIMI_CODE_USER_AGENT,
     "X-Msh-Platform": KIMI_PLATFORM,
-    "X-Msh-Version": KIMI_CLI_VERSION,
+    "X-Msh-Version": KIMI_CODE_VERSION,
     "X-Msh-Device-Name": os.hostname(),
     "X-Msh-Device-Model": DEVICE_MODEL,
     "X-Msh-Os-Version": getOsVersion(),

package/src/oauth.ts

@@ -1,4 +1,4 @@
-// OAuth subsystem: device flow, refresh-with-retry, kimi-cli credential
+// OAuth subsystem: device flow, refresh-with-retry, Kimi credential
 // reuse, the login / refresh handlers wired into pi's OAuth interface, and
 // the stream-level auth refresh used by the streaming handler.
 
@@ -183,13 +183,13 @@ export async function refreshAccessToken(
 }
 
 // =============================================================================
-// Reuse existing kimi-cli credentials
+// Reuse existing Kimi credentials
 //
-// Users who already ran the upstream `kimi-cli` and signed in have a valid
-// OAuth token sitting at `$KIMI_SHARE_DIR/credentials/kimi-code.json`
-// (defaults to `~/.kimi/...`). Loading it lets users skip the device-flow
-// dance entirely. Read-only: we never overwrite kimi-cli's file, only seed
-// pi's auth.json via the value returned to pi's OAuth callback.
+// Users who already ran the upstream Kimi Code CLI and signed in have a valid
+// OAuth token under `$KIMI_CODE_HOME/credentials/kimi-code.json` (defaults to
+// `~/.kimi-code/...`). We also keep read-only support for legacy kimi-cli
+// credentials under `$KIMI_SHARE_DIR/credentials/kimi-code.json` (defaults to
+// `~/.kimi/...`). Loading either lets users skip the device-flow dance.
 // =============================================================================
 
 interface KimiCliCredentialsFile {
@@ -198,21 +198,27 @@ interface KimiCliCredentialsFile {
   expires_at?: number; // Unix seconds (upstream convention)
 }
 
-function getKimiCliCredentialsPath(): string {
+function getKimiCredentialPaths(): string[] {
+  const kimiCodeHome = process.env.KIMI_CODE_HOME || join(os.homedir(), ".kimi-code");
   const shareDir = process.env.KIMI_SHARE_DIR || join(os.homedir(), ".kimi");
-  return join(shareDir, "credentials", "kimi-code.json");
+  return [
+    join(kimiCodeHome, "credentials", "kimi-code.json"),
+    join(shareDir, "credentials", "kimi-code.json"),
+  ];
 }
 
 function readKimiCliCredentials(): KimiCliCredentialsFile | null {
-  const path = getKimiCliCredentialsPath();
-  try {
-    if (!existsSync(path)) return null;
-    const data = JSON.parse(readFileSync(path, "utf-8")) as KimiCliCredentialsFile;
-    if (!data.access_token || !data.refresh_token) return null;
-    return data;
-  } catch {
-    return null;
+  for (const path of getKimiCredentialPaths()) {
+    try {
+      if (!existsSync(path)) continue;
+      const data = JSON.parse(readFileSync(path, "utf-8")) as KimiCliCredentialsFile;
+      if (!data.access_token || !data.refresh_token) continue;
+      return data;
+    } catch {
+      continue;
+    }
   }
+  return null;
 }
 
 async function tryReuseKimiCliCredentials(
@@ -226,7 +232,7 @@ async function tryReuseKimiCliCredentials(
   // between this returning and the first API call.
   const stillFresh = expiresAtMs > Date.now() + 60_000;
 
-  callbacks.onProgress?.("Found existing kimi-cli credentials, reusing them.");
+  callbacks.onProgress?.("Found existing Kimi credentials, reusing them.");
 
   if (stillFresh) {
     const extras = await discoverKimiModelMetadata(data.access_token!);
@@ -238,7 +244,7 @@ async function tryReuseKimiCliCredentials(
     };
   }
 
-  callbacks.onProgress?.("kimi-cli access token expired, refreshing.");
+  callbacks.onProgress?.("Kimi access token expired, refreshing.");
   try {
     const token = await refreshAccessToken(data.refresh_token!);
     const extras = await discoverKimiModelMetadata(token.access_token);
@@ -249,7 +255,7 @@ async function tryReuseKimiCliCredentials(
       ...extras,
     };
   } catch {
-    callbacks.onProgress?.("Refresh of kimi-cli token failed, falling back to device flow.");
+    callbacks.onProgress?.("Refresh of Kimi token failed, falling back to device flow.");
     return null;
   }
 }
@@ -382,6 +388,7 @@ export async function refreshKimiAuthToken(currentKey: string): Promise<string |
     console.error("[kimi-coding] auth refresh: requesting new access token");
     const refreshed = await refreshAccessToken(cred.refresh);
     const newCred: OAuthCredential = {
+      ...cred,
       type: "oauth",
       access: refreshed.access_token,
       refresh: refreshed.refresh_token,

package/src/payload.ts

@@ -19,7 +19,7 @@ export type Uploader = (mimeType: string, data: string) => Promise<string | null
 export interface KimiEnvOverrides {
   temperature?: number;
   topP?: number;
-  maxTokens?: number;
+  maxCompletionTokens?: number;
 }
 
 export function resolveCacheRetention(value?: CacheRetention): CacheRetention {
@@ -87,8 +87,8 @@ export function readEnvOverrides(): KimiEnvOverrides {
   if (temp) out.temperature = parseFloat(temp);
   const topP = process.env.KIMI_MODEL_TOP_P;
   if (topP) out.topP = parseFloat(topP);
-  const maxTokens = process.env.KIMI_MODEL_MAX_TOKENS;
-  if (maxTokens) out.maxTokens = parseInt(maxTokens, 10);
+  const maxCompletionTokens = process.env.KIMI_MODEL_MAX_COMPLETION_TOKENS;
+  if (maxCompletionTokens) out.maxCompletionTokens = parseInt(maxCompletionTokens, 10);
   return out;
 }
 
@@ -420,11 +420,19 @@ export async function applyKimiPayloadMutations(
     if (resolved) payload.prompt_cache_key = resolved;
   }
 
-  // 4. Env-level hyperparameter overrides (pre-parsed into numbers by caller).
-  const { temperature, topP, maxTokens } = ctx.envOverrides;
+  // 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;
+  }
+  delete payload.max_tokens;
+
+  const { temperature, topP, maxCompletionTokens } = ctx.envOverrides;
   if (temperature !== undefined) payload.temperature = temperature;
   if (topP !== undefined) payload.top_p = topP;
-  if (maxTokens !== undefined) payload.max_tokens = maxTokens;
+  if (maxCompletionTokens !== undefined) {
+    payload.max_completion_tokens = maxCompletionTokens;
+  }
 
   // 5. Reasoning effort mapping.
   if (ctx.reasoning) {

package/src/stream.ts

@@ -46,24 +46,50 @@ export async function* filterEmptyResponseStream(
 ): AsyncIterable<AssistantMessageEvent> {
   const suppressedIndices = new Set<number>();
   let textBuffer: AssistantMessageEvent[] = [];
+  let bufferedText = "";
   let bufferingIndex: number | null = null;
 
+  const suppressBufferedTextBlock = (): void => {
+    if (bufferingIndex !== null) suppressedIndices.add(bufferingIndex);
+    textBuffer = [];
+    bufferedText = "";
+    bufferingIndex = null;
+  };
+
+  const flushBufferedTextBlock = async function* (): AsyncIterable<AssistantMessageEvent> {
+    for (const buffered of textBuffer) yield buffered;
+    textBuffer = [];
+    bufferedText = "";
+    bufferingIndex = null;
+  };
+
   for await (const event of upstream) {
-    // Start buffering when a new text block begins.
+    // Start buffering only long enough to decide whether this text block is
+    // Kimi's synthetic "(Empty response: ...)" wrapper. Normal text is flushed
+    // as soon as it diverges from the marker so output still streams.
     if (event.type === "text_start") {
       bufferingIndex = event.contentIndex;
       textBuffer = [event];
+      bufferedText = "";
       continue;
     }
 
-    // Accumulate text deltas + detect the empty-response marker on text_end.
     if (
       bufferingIndex !== null &&
       "contentIndex" in event &&
       event.contentIndex === bufferingIndex
     ) {
       if (event.type === "text_delta") {
+        bufferedText += event.delta;
         textBuffer.push(event);
+        if (bufferedText.startsWith(EMPTY_RESPONSE_PREFIX)) {
+          suppressBufferedTextBlock();
+          continue;
+        }
+        if (EMPTY_RESPONSE_PREFIX.startsWith(bufferedText)) {
+          continue;
+        }
+        yield* flushBufferedTextBlock();
         continue;
       }
       if (event.type === "text_end") {
@@ -72,14 +98,11 @@ export async function* filterEmptyResponseStream(
           // array: it is a shared reference into session state, and mutating
           // it would shift subsequent contentIndex values, corrupting the
           // stream.
-          suppressedIndices.add(bufferingIndex);
+          suppressBufferedTextBlock();
         } else {
-          // Legitimate text block — flush buffered events + end event.
-          for (const buffered of textBuffer) yield buffered;
+          yield* flushBufferedTextBlock();
           yield event;
         }
-        textBuffer = [];
-        bufferingIndex = null;
         continue;
       }
     }
@@ -103,6 +126,10 @@ export async function* filterEmptyResponseStream(
 
     yield event;
   }
+
+  if (bufferingIndex !== null) {
+    yield* flushBufferedTextBlock();
+  }
 }
 
 // =============================================================================

package/src/tools/moonshot.ts

@@ -3,6 +3,7 @@ import { Type, type Static } from "@earendil-works/pi-ai";
 
 import { PROVIDER_ID } from "../constants.ts";
 import { getCommonHeaders } from "../device.ts";
+import { refreshKimiAuthToken } from "../oauth.ts";
 
 const MOONSHOT_BASE_V1 = "https://api.kimi.com/coding/v1";
 const MOONSHOT_TIMEOUT_MS = 180_000;
@@ -47,6 +48,7 @@ export interface MoonshotFetchResult {
 interface MoonshotToolDeps {
   fetch: typeof fetch;
   getAccessToken: () => string | null;
+  refreshAccessToken: (currentToken: string) => Promise<string | null>;
 }
 
 export interface BuildMoonshotToolOptions {
@@ -68,6 +70,7 @@ function buildDeps(options: BuildMoonshotToolOptions = {}): MoonshotToolDeps {
   return {
     fetch: options.deps?.fetch ?? fetch,
     getAccessToken: options.deps?.getAccessToken ?? defaultGetAccessToken,
+    refreshAccessToken: options.deps?.refreshAccessToken ?? refreshKimiAuthToken,
   };
 }
 
@@ -196,6 +199,19 @@ async function readErrorBody(response: Response): Promise<string> {
   return response.text().catch(() => "");
 }
 
+async function fetchWithAuthRetry(
+  deps: MoonshotToolDeps,
+  accessToken: string,
+  request: (token: string) => Promise<Response>,
+): Promise<Response> {
+  const response = await request(accessToken);
+  if (response.status !== 401) return response;
+
+  const refreshed = await deps.refreshAccessToken(accessToken);
+  if (!refreshed || refreshed === accessToken) return response;
+  return request(refreshed);
+}
+
 export function buildMoonshotSearchTool(options: BuildMoonshotToolOptions = {}) {
   const deps = buildDeps(options);
   const defaultCollapsed = options.defaultCollapsed ?? true;
@@ -219,17 +235,19 @@ export function buildMoonshotSearchTool(options: BuildMoonshotToolOptions = {})
       const includeContent = params.include_content === true;
       const timeout = buildTimeoutSignal(signal);
       try {
-        const response = await deps.fetch(`${MOONSHOT_BASE_V1}/search`, {
-          method: "POST",
-          headers: buildHeaders(accessToken, toolCallId),
-          body: JSON.stringify({
-            text_query: params.query,
-            limit,
-            enable_page_crawling: includeContent,
-            timeout_seconds: 30,
+        const response = await fetchWithAuthRetry(deps, accessToken, (token) =>
+          deps.fetch(`${MOONSHOT_BASE_V1}/search`, {
+            method: "POST",
+            headers: buildHeaders(token, toolCallId),
+            body: JSON.stringify({
+              text_query: params.query,
+              limit,
+              enable_page_crawling: includeContent,
+              timeout_seconds: 30,
+            }),
+            signal: timeout.signal,
           }),
-          signal: timeout.signal,
-        });
+        );
 
         if (!response.ok) {
           const body = await readErrorBody(response);
@@ -279,15 +297,17 @@ export function buildMoonshotFetchTool(options: BuildMoonshotToolOptions = {}) {
 
       const timeout = buildTimeoutSignal(signal);
       try {
-        const response = await deps.fetch(`${MOONSHOT_BASE_V1}/fetch`, {
-          method: "POST",
-          headers: {
-            ...buildHeaders(accessToken, toolCallId),
-            Accept: "text/markdown",
-          },
-          body: JSON.stringify({ url: params.url }),
-          signal: timeout.signal,
-        });
+        const response = await fetchWithAuthRetry(deps, accessToken, (token) =>
+          deps.fetch(`${MOONSHOT_BASE_V1}/fetch`, {
+            method: "POST",
+            headers: {
+              ...buildHeaders(token, toolCallId),
+              Accept: "text/markdown",
+            },
+            body: JSON.stringify({ url: params.url }),
+            signal: timeout.signal,
+          }),
+        );
 
         if (!response.ok) {
           const body = await readErrorBody(response);