pi-provider-kimi-code 0.5.0 → 0.5.1

package/package.json

@@ -1,39 +1,39 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.5.0",
+  "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,10 +24,9 @@ export const DEFAULT_BASE_URL = IS_OPENAI_PROTOCOL
   ? "https://api.kimi.com/coding/v1"
   : "https://api.kimi.com/coding";
 
-export const KIMI_CODE_VERSION = "0.1.1";
-export const KIMI_CODE_USER_AGENT_PRODUCT = "kimi-code-cli";
-export const KIMI_CODE_USER_AGENT = `${KIMI_CODE_USER_AGENT_PRODUCT}/${KIMI_CODE_VERSION}`;
-export const KIMI_PLATFORM = "kimi-code-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 function getKimiCodeHome(): string {
   const value = process.env.KIMI_CODE_HOME?.trim();

package/src/oauth.ts

@@ -388,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

@@ -87,8 +87,7 @@ 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 maxCompletionTokens =
-    process.env.KIMI_MODEL_MAX_COMPLETION_TOKENS ?? process.env.KIMI_MODEL_MAX_TOKENS;
+  const maxCompletionTokens = process.env.KIMI_MODEL_MAX_COMPLETION_TOKENS;
   if (maxCompletionTokens) out.maxCompletionTokens = parseInt(maxCompletionTokens, 10);
   return out;
 }
@@ -421,13 +420,18 @@ export async function applyKimiPayloadMutations(
     if (resolved) payload.prompt_cache_key = resolved;
   }
 
-  // 4. Env-level hyperparameter overrides (pre-parsed into numbers by caller).
+  // 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 (maxCompletionTokens !== undefined) {
     payload.max_completion_tokens = maxCompletionTokens;
-    delete payload.max_tokens;
   }
 
   // 5. Reasoning effort mapping.

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);