pi-provider-kimi-code 0.3.0 → 0.3.1

package/index.ts

@@ -40,6 +40,9 @@ const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
 const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
 const PROTOCOL =
   process.env.KIMI_CODE_PROTOCOL === "openai" ? "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.
+const KIMI_API_TYPE = PROTOCOL === "openai-completions" ? "kimi-openai-completions" : "kimi-anthropic-messages";
 const DEFAULT_BASE_URL =
   PROTOCOL === "openai-completions"
     ? "https://api.kimi.com/coding/v1"
@@ -112,11 +115,32 @@ function getDeviceModel(): string {
     return version && arch ? `macOS ${version} ${arch}` : `macOS ${arch}`;
   }
   if (platform === "win32") {
-    const release = os.release();
+    // Only show the major release (e.g. "Windows 10", "Windows 11") to match
+    // the upstream kimi-cli behavior in `def _device_model() -> str:`.
+    // See: https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/auth/oauth.py
+    const parts = os.release().split(".");
+    let release = parts[0];
+    if (release === "10" && parts.length >= 3) {
+      const build = parseInt(parts[2], 10);
+      if (!isNaN(build) && build >= 22000) {
+        release = "11";
+      }
+    }
     return release && arch ? `Windows ${release} ${arch}` : `Windows ${arch}`;
   }
+  // Normalize platform name to match Python `platform.system()` casing used by
+  // upstream kimi-cli (e.g. "Linux", "FreeBSD", "SunOS"), since Node's
+  // `process.platform` is always lower-case.
+  const SYSTEM_NAME: Record<string, string> = {
+    aix: "AIX",
+    freebsd: "FreeBSD",
+    linux: "Linux",
+    openbsd: "OpenBSD",
+    sunos: "SunOS",
+  };
+  const system = SYSTEM_NAME[platform] ?? platform;
   const release = os.release();
-  return release && arch ? `${platform} ${release} ${arch}` : `${platform} ${arch}`;
+  return release && arch ? `${system} ${release} ${arch}` : `${system} ${arch}`;
 }
 
 function asciiHeaderValue(value: string, fallback = "unknown"): string {
@@ -786,9 +810,12 @@ function streamSimpleKimi(
     const upload: Uploader | undefined = apiKey
       ? (mimeType, data) => uploadKimiFile(apiKey, mimeType, data)
       : undefined;
+    // Only forward apiKey if we actually have one — never override the
+    // caller's credential (e.g. Claude Code OAuth token) with an empty string.
+    const apiKeyOverride = apiKey ? { apiKey } : {};
     return {
       ...options,
-      apiKey,
+      ...apiKeyOverride,
       onPayload: async (payload, modelData) => {
         let nextPayload: unknown = payload;
 
@@ -819,8 +846,11 @@ function streamSimpleKimi(
 
     while (true) {
       const patchedOptions = buildPatchedOptions(currentKey);
+      // Route by the module-level PROTOCOL, not model.api, since we register
+      // with a custom api type (kimi-openai-completions / kimi-anthropic-messages)
+      // to avoid overriding the built-in Anthropic/OpenAI stream handlers.
       const upstream =
-        model.api === "openai-completions"
+        PROTOCOL === "openai-completions"
           ? streamSimpleOpenAICompletions(
               model as Model<"openai-completions">,
               context,
@@ -828,22 +858,30 @@ function streamSimpleKimi(
             )
           : streamSimpleAnthropic(model as Model<"anthropic-messages">, context, patchedOptions);
 
-      let pushedAny = false;
       let shouldRetry = false;
+      let prefixBuffer: AssistantMessageEvent[] = [];
 
       try {
         for await (const event of filterEmptyResponseStream(upstream)) {
-          // If the upstream terminates with an error before we've emitted
-          // anything downstream, speculatively try an OAuth refresh and
-          // retry once. This handles the common case of a server-side token
-          // invalidation before the local `expires` lapses, without having
-          // to pattern-match every possible error-message format.
-          //
-          // Non-auth errors (overflow, network, rate-limit, etc.) still
-          // trigger one wasted refresh, but the retried request fails the
-          // same way and we forward it — pi-coding-agent's own recovery
-          // paths (compaction, retry) take over from there.
-          if (!pushedAny && attempt === 0 && event.type === "error") {
+          // streamAnthropic emits a synthetic "start" event synchronously,
+          // before the for-await loop begins iterating and therefore before
+          // the HTTP request is actually made.  If the request 401s, the loop
+          // throws and the catch block emits "error".  Without buffering, the
+          // "start" event (which carries an empty AssistantMessage) leaks into
+          // the session history and the TUI, leaving a phantom empty assistant
+          // bubble.  We buffer "start" events and only flush them once we see
+          // a non-error event that proves the stream is alive.
+          if (event.type === "start") {
+            prefixBuffer.push(event);
+            continue;
+          }
+
+          // Speculative OAuth refresh on the first error.  We retry once so
+          // that short-lived Kimi tokens invalidated by the server before the
+          // local expires timestamp lapses don't surface as raw 401s to the
+          // user.  Non-auth errors still trigger one wasted refresh, but the
+          // retried request fails the same way and we forward it.
+          if (attempt === 0 && event.type === "error") {
             console.error(
               `[kimi-coding] upstream error on first event, attempting refresh: ${event.error?.errorMessage?.slice(0, 200)}`,
             );
@@ -852,26 +890,50 @@ function streamSimpleKimi(
               console.error("[kimi-coding] retrying stream with refreshed token");
               currentKey = refreshed;
               shouldRetry = true;
-              break;
+              break; // discard prefixBuffer — don't leak the stale start
             }
             console.error(
               "[kimi-coding] refresh did not yield a new token, forwarding original error",
             );
           }
+
+          // First non-start, non-retry event: flush buffered prefix, then
+          // stream normally.
+          for (const e of prefixBuffer) filtered.push(e);
+          prefixBuffer = [];
           filtered.push(event);
-          pushedAny = true;
         }
+
+        // Stream ended normally: flush any remaining buffered starts.
+        for (const e of prefixBuffer) filtered.push(e);
       } catch (err) {
+        // Upstream threw rather than emitting a stream `error` event. This can
+        // be the same stale-token 401 surfaced as an exception (depending on
+        // the SDK path / network layer), so mirror the in-stream refresh
+        // branch: on attempt 0, try one OAuth refresh + retry. Either way,
+        // discard `prefixBuffer` — we never confirmed the stream actually
+        // started, and flushing the buffered `start` would resurrect the
+        // phantom empty assistant message this PR set out to fix.
         console.error("[kimi-coding] stream error:", err);
-        filtered.push({
-          type: "error",
-          reason: "error",
-          error: {
-            content: [],
-            stopReason: "error",
-            usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
-          },
-        } as AssistantMessageEvent & { type: "error" });
+        if (attempt === 0) {
+          const refreshed = await refreshKimiAuthToken(currentKey);
+          if (refreshed && refreshed !== currentKey) {
+            console.error("[kimi-coding] retrying stream after thrown error with refreshed token");
+            currentKey = refreshed;
+            shouldRetry = true;
+          }
+        }
+        if (!shouldRetry) {
+          filtered.push({
+            type: "error",
+            reason: "error",
+            error: {
+              content: [],
+              stopReason: "error",
+              usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
+            },
+          } as AssistantMessageEvent & { type: "error" });
+        }
       }
 
       if (shouldRetry) {
@@ -893,7 +955,7 @@ export default function (pi: ExtensionAPI) {
   pi.registerProvider("kimi-coding", {
     baseUrl: getBaseUrl(),
     apiKey: "KIMI_API_KEY",
-    api: PROTOCOL,
+    api: KIMI_API_TYPE,
     streamSimple: streamSimpleKimi,
 
     headers: getCommonHeaders(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Pi extension for Kimi Code — reuse your Kimi Code Plan in pi-coding-agent (K2.6, K2.5)",
   "keywords": [
     "pi-package",