pi-provider-kimi-code 0.6.3 → 0.6.5

package/README.md

@@ -102,16 +102,18 @@ KIMI_API_KEY=sk-... pi
 
 ## Model
 
-This provider publishes one Pi model ID:
+This provider publishes two Pi model IDs:
 
 ```text
 kimi-coding/kimi-for-coding
+kimi-coding/kimi-for-coding-highspeed
 ```
 
-Select it inside Pi:
+Select standard or highspeed mode inside Pi:
 
 ```text
 /model kimi-coding/kimi-for-coding
+/model kimi-coding/kimi-for-coding-highspeed
 ```
 
 Kimi keeps Coding models behind aliases. Rather than hardcoding a stale model list, this extension asks Kimi for the current model info when you log in or refresh. If your account is on a newer rollout (e.g., Kimi K2.7) or internal test, Pi can pick up the latest model name and context size without waiting for a package release.
@@ -123,7 +125,7 @@ Fallback values:
 - Input: text and image
 - Reasoning: enabled
 
-The provider maps Pi's reasoning levels to Kimi's `reasoning_effort` and top-level `thinking` parameters. The mapping refreshes automatically on credential refresh. Opening `/kimi-settings` also re-discovers the latest model metadata.
+The provider maps Pi's reasoning levels to Kimi's top-level `thinking` parameter. It sends `thinking.effort` only when `/models` advertises supported effort values. The mapping refreshes automatically on credential refresh. Opening `/kimi-settings` also re-discovers the latest model metadata.
 
 ## Optional tools
 
@@ -135,7 +137,7 @@ Inside Pi, run:
 /kimi-settings
 ```
 
-That command shows the current server-side model name (e.g. "K2.7 Code High Speed"), your Kimi usage summary, and lets you edit the home or project config. Changes apply to the active session tool set.
+That command shows the current server-side model name (e.g. "K2.7 Code High Speed"), your Kimi quota and Extra Usage balance, and lets you edit the home or project config. Changes apply to the active session tool set.
 
 Configurable settings include protocol mode, upload threshold, and per-tool enable/collapse.
 
@@ -277,7 +279,7 @@ Kimi's cache is **content-based**: it fires automatically when your prompt prefi
 - A timestamp, request ID, or randomized header is being interpolated into the prompt.
 - The first ~256 tokens of the prompt differ between turns.
 
-`PI_CACHE_RETENTION=none` skips `prompt_cache_key` injection but **does not** disable Kimi's caching (the cache is unconditional). For deterministic measurement, run `scripts/test_e2e.sh` with `KIMI_E2E_ONLY_CACHE=1`. See [docs/caching.md](docs/caching.md) for full mechanics.
+`PI_CACHE_RETENTION=none` skips `prompt_cache_key` injection but **does not** disable Kimi's caching (the cache is unconditional). For deterministic measurement, run a focused suite under `scripts/e2e/cache/`, starting with `scripts/e2e/cache/ttl.sh`. See [docs/caching.md](docs/caching.md) for full mechanics.
 
 ### OpenAI-compatible tools complain about a `developer` role
 

package/index.ts

@@ -44,10 +44,13 @@ import {
   type KimiOAuthExtras,
   buildKimiModelFromConfig,
   applyKimiOAuthExtrasToModel,
+  KIMI_CODING_HIGHSPEED_MODEL_ID,
+  KIMI_CODING_MODEL_ID,
   discoverKimiModelMetadata,
+  getKimiModelMetadata,
   resolveKimiModelConfig,
 } from "./src/models.ts";
-import { loginKimiCode, refreshKimiCodeToken } from "./src/oauth.ts";
+import { getKimiApiKey, loginKimiCode, refreshKimiCodeToken } from "./src/oauth.ts";
 import { isKimiProjectConfigApproved } from "./src/project-trust.ts";
 import {
   type KimiConfigScope,
@@ -114,7 +117,10 @@ function reloadEffectiveKimiRuntimeConfig(
   state.config = config;
   state.projectTrusted = projectTrusted;
   setStoreResolvedKimiConfig({
-    model: resolveKimiModelConfig(config.model, state.modelExtras),
+    model: resolveKimiModelConfig(
+      config.model,
+      getKimiModelMetadata(state.modelExtras, KIMI_CODING_MODEL_ID),
+    ),
     protocol: config.protocol,
     uploads: config.uploads,
   });
@@ -132,13 +138,13 @@ function applyEffectiveKimiRuntimeConfig(
   return config;
 }
 
-async function refreshModelExtras(state: KimiRuntimeState): Promise<void> {
+async function refreshModelExtras(state: KimiRuntimeState): Promise<boolean> {
   const token = getKimiUsageToken();
-  if (!token) return;
+  if (!token) return false;
   const extras = await discoverKimiModelMetadata(token, state.config.protocol);
-  if (Object.keys(extras).length > 0) {
-    Object.assign(state.modelExtras, extras);
-  }
+  if (Object.keys(extras).length === 0) return false;
+  Object.assign(state.modelExtras, extras);
+  return true;
 }
 
 async function openSettingsMenu(
@@ -146,7 +152,11 @@ async function openSettingsMenu(
   ctx: ExtensionCommandContext,
   state: KimiRuntimeState,
 ): Promise<void> {
-  const [usage] = await Promise.all([fetchKimiUsageSummary(), refreshModelExtras(state)]);
+  const [usage, modelsRefreshed] = await Promise.all([
+    fetchKimiUsageSummary(),
+    refreshModelExtras(state),
+  ]);
+  if (modelsRefreshed) registerKimiProvider(pi, state);
 
   const projectTrusted = await isKimiProjectConfigApproved(ctx, ctx.cwd);
   const homeDraft = loadHomeKimiCodeConfig(os.homedir());
@@ -354,10 +364,22 @@ function saveScopeKimiCodeConfig(
   }
 }
 
+function filterAvailableKimiModels<T extends { id: string }>(
+  models: T[],
+  extras: KimiOAuthExtras,
+): T[] {
+  const available = extras.modelCatalog ? new Set(Object.keys(extras.modelCatalog)) : null;
+  return available ? models.filter((model) => available.has(model.id)) : models;
+}
+
 function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
-  const model = applyKimiOAuthExtrasToModel(
+  const standardModel = applyKimiOAuthExtrasToModel(
     buildKimiModelFromConfig(state.config.model),
-    state.modelExtras,
+    getKimiModelMetadata(state.modelExtras, KIMI_CODING_MODEL_ID),
+  );
+  const highSpeedModel = applyKimiOAuthExtrasToModel(
+    buildKimiModelFromConfig(state.config.model, KIMI_CODING_HIGHSPEED_MODEL_ID),
+    getKimiModelMetadata(state.modelExtras, KIMI_CODING_HIGHSPEED_MODEL_ID),
   );
 
   pi.registerProvider(PROVIDER_ID, {
@@ -366,13 +388,13 @@ function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
     api: getKimiApiType(state.config.protocol),
     streamSimple: streamSimpleKimi,
 
-    models: [model],
+    models: filterAvailableKimiModels([standardModel, highSpeedModel], state.modelExtras),
 
     oauth: {
       name: "Kimi Code (OAuth)",
       login: loginKimiCode,
       refreshToken: refreshKimiCodeToken,
-      getApiKey: (cred) => cred.access,
+      getApiKey: getKimiApiKey,
       // Reflect server-side model identity on the registered model after login
       // / refresh. We never rewrite the model id (pi-side `/model` selections
       // and persisted sessions reference it); only the human-facing name, the
@@ -382,10 +404,16 @@ function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
         const extras = cred as KimiOAuthCredentials;
         state.modelExtras = extras;
         reloadEffectiveKimiRuntimeConfig(state, state.cwd, state.projectTrusted);
-        return models.map((model) => {
-          if (model.id !== "kimi-for-coding") return model;
-          return applyKimiOAuthExtrasToModel(model, extras);
-        });
+        const available = extras.modelCatalog ? new Set(Object.keys(extras.modelCatalog)) : null;
+        return models
+          .filter(
+            (model) => model.provider !== PROVIDER_ID || !available || available.has(model.id),
+          )
+          .map((model) =>
+            model.provider === PROVIDER_ID
+              ? applyKimiOAuthExtrasToModel(model, getKimiModelMetadata(extras, model.id))
+              : model,
+          );
       },
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
   "keywords": [
     "ai-provider",

package/src/config.ts

@@ -38,6 +38,8 @@ export interface ModelConfig {
 
 export interface KimiResolvedModelConfig extends ModelConfig {
   supportsThinkingType?: "only" | "no" | "both";
+  supportEfforts?: string[];
+  defaultEffort?: string;
 }
 
 export interface KimiCodeConfig {

package/src/constants.ts

@@ -41,12 +41,12 @@ export function getDefaultBaseUrl(protocol: KimiWireProtocol): string {
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const PROVIDER_VERSION = "0.6.3";
+export const PROVIDER_VERSION = "0.6.5";
 
 // Upstream kimi-code CLI version — used in User-Agent and X-Msh-Version
 // headers to match the official client's identity. Update this when
 // syncing with https://github.com/anthropics/kimi-code.
-export const KIMI_UPSTREAM_VERSION = "0.18.0";
+export const KIMI_UPSTREAM_VERSION = "0.23.4";
 export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_UPSTREAM_VERSION}`;
 export const KIMI_PLATFORM = "kimi_code_cli";
 

package/src/device.ts

@@ -152,6 +152,22 @@ function getStableDeviceId(): string {
   return DEVICE_ID;
 }
 
+export function parseKimiCodeCustomHeaders(
+  env: NodeJS.ProcessEnv = process.env,
+): Record<string, string> {
+  const raw = env.KIMI_CODE_CUSTOM_HEADERS?.trim();
+  if (!raw) return {};
+  const headers: Record<string, string> = {};
+  for (const line of raw.split("\n")) {
+    const colon = line.indexOf(":");
+    if (colon < 0) continue;
+    const name = line.slice(0, colon).trim();
+    if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) continue;
+    headers[name] = asciiHeaderValue(line.slice(colon + 1));
+  }
+  return headers;
+}
+
 export function getCommonHeaders(): Record<string, string> {
   const headers = {
     "User-Agent": KIMI_CODE_USER_AGENT,
@@ -166,3 +182,28 @@ export function getCommonHeaders(): Record<string, string> {
     Object.entries(headers).map(([key, value]) => [key, asciiHeaderValue(value)]),
   ) as Record<string, string>;
 }
+
+const RESERVED_PROVIDER_HEADERS = new Set([
+  "accept",
+  "anthropic-version",
+  "authorization",
+  "content-type",
+  "user-agent",
+  "x-api-key",
+]);
+
+function isReservedProviderHeader(name: string): boolean {
+  const normalized = name.toLowerCase();
+  return RESERVED_PROVIDER_HEADERS.has(normalized) || normalized.startsWith("x-msh-");
+}
+
+export function getKimiProviderHeaders(
+  env: NodeJS.ProcessEnv = process.env,
+): Record<string, string> {
+  const customHeaders = Object.fromEntries(
+    Object.entries(parseKimiCodeCustomHeaders(env)).filter(
+      ([name]) => !isReservedProviderHeader(name),
+    ),
+  );
+  return { ...customHeaders, ...getCommonHeaders() };
+}

package/src/models.ts

@@ -5,9 +5,9 @@ import type { Api, Model, OAuthCredentials } from "@earendil-works/pi-ai";
 import type { KimiInputModality, KimiResolvedModelConfig, ModelConfig } from "./config.ts";
 
 import { type KimiWireProtocol, getBaseUrl } from "./constants.ts";
-import { getCommonHeaders } from "./device.ts";
+import { getKimiProviderHeaders } from "./device.ts";
 
-export interface KimiOAuthExtras {
+export interface KimiModelMetadata {
   wireModelId?: string;
   modelDisplay?: string;
   contextLength?: number;
@@ -15,6 +15,13 @@ export interface KimiOAuthExtras {
   supportsImageIn?: boolean;
   supportsVideoIn?: boolean;
   supportsThinkingType?: "only" | "no" | "both";
+  protocol?: KimiWireProtocol;
+  supportEfforts?: string[];
+  defaultEffort?: string;
+}
+
+export interface KimiOAuthExtras extends KimiModelMetadata {
+  modelCatalog?: Record<string, KimiModelMetadata>;
 }
 
 export type KimiOAuthCredentials = OAuthCredentials & KimiOAuthExtras;
@@ -47,6 +54,9 @@ function mergeInputModalities(
 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 };
 
+export const KIMI_CODING_MODEL_ID = "kimi-for-coding";
+export const KIMI_CODING_HIGHSPEED_MODEL_ID = "kimi-for-coding-highspeed";
+
 function resolveModelCost(modelDisplay: string | undefined): {
   input: number;
   output: number;
@@ -57,13 +67,17 @@ function resolveModelCost(modelDisplay: string | undefined): {
   return COST_STANDARD;
 }
 
-export function buildKimiModelFromConfig(config: ModelConfig): Model<Api> {
+export function buildKimiModelFromConfig(
+  config: ModelConfig,
+  modelId = KIMI_CODING_MODEL_ID,
+): Model<Api> {
+  const isHighSpeed = modelId === KIMI_CODING_HIGHSPEED_MODEL_ID;
   return {
-    id: "kimi-for-coding",
-    name: "Kimi for Coding",
+    id: modelId,
+    name: isHighSpeed ? "Kimi for Coding High Speed" : "Kimi for Coding",
     reasoning: config.reasoning,
     input: [...config.input] as unknown as ("text" | "image" | "video")[],
-    cost: { ...COST_STANDARD },
+    cost: { ...(isHighSpeed ? COST_HIGH_SPEED : COST_STANDARD) },
     contextWindow: config.contextWindow,
     maxTokens: config.maxTokens,
   } as Model<Api>;
@@ -86,6 +100,8 @@ export function resolveKimiModelConfig(
   if (typeof extras.supportsImageIn === "boolean" || typeof extras.supportsVideoIn === "boolean") {
     resolved.input = mergeInputModalities(resolved.input, extras);
   }
+  if (extras.supportEfforts) resolved.supportEfforts = [...extras.supportEfforts];
+  if (extras.defaultEffort) resolved.defaultEffort = extras.defaultEffort;
   return resolved;
 }
 
@@ -97,6 +113,8 @@ interface KimiServerModel {
   supports_image_in?: unknown;
   supports_video_in?: unknown;
   supports_thinking_type?: unknown;
+  protocol?: unknown;
+  think_efforts?: unknown;
 }
 
 function parseSupportsThinkingType(value: unknown): "only" | "no" | "both" | undefined {
@@ -104,6 +122,54 @@ function parseSupportsThinkingType(value: unknown): "only" | "no" | "both" | und
   return undefined;
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseThinkEfforts(value: unknown): {
+  supportEfforts?: string[];
+  defaultEffort?: string;
+} {
+  if (!isRecord(value) || value.support !== true) return {};
+  const validEfforts = Array.isArray(value.valid_efforts)
+    ? value.valid_efforts.filter(
+        (effort): effort is string => typeof effort === "string" && !!effort,
+      )
+    : [];
+  return {
+    ...(validEfforts.length > 0 ? { supportEfforts: validEfforts } : {}),
+    ...(typeof value.default_effort === "string" && value.default_effort
+      ? { defaultEffort: value.default_effort }
+      : {}),
+  };
+}
+
+function parseKimiModelMetadata(model: KimiServerModel): KimiModelMetadata | undefined {
+  if (typeof model.id !== "string" || !model.id) return undefined;
+  const metadata: KimiModelMetadata = { wireModelId: model.id };
+  if (typeof model.display_name === "string") metadata.modelDisplay = model.display_name;
+  if (typeof model.context_length === "number" && model.context_length > 0) {
+    metadata.contextLength = model.context_length;
+  }
+  const thinkingType = parseSupportsThinkingType(model.supports_thinking_type);
+  if (thinkingType) {
+    metadata.supportsThinkingType = thinkingType;
+  } else if (typeof model.supports_reasoning === "boolean") {
+    metadata.supportsReasoning = model.supports_reasoning;
+  }
+  if (typeof model.supports_image_in === "boolean") {
+    metadata.supportsImageIn = model.supports_image_in;
+  }
+  if (typeof model.supports_video_in === "boolean") {
+    metadata.supportsVideoIn = model.supports_video_in;
+  }
+  if (model.protocol === "openai" || model.protocol === "anthropic") {
+    metadata.protocol = model.protocol;
+  }
+  Object.assign(metadata, parseThinkEfforts(model.think_efforts));
+  return metadata;
+}
+
 export function buildModelsUrl(baseUrl: string): string {
   const base = baseUrl.replace(/\/+$/, "");
   return base.endsWith("/v1") ? `${base}/models` : `${base}/v1/models`;
@@ -127,7 +193,7 @@ export async function discoverKimiModelMetadata(
     const response = await fetch(getModelsUrl(protocol), {
       signal: controller.signal,
       headers: {
-        ...getCommonHeaders(),
+        ...getKimiProviderHeaders(),
         Authorization: `Bearer ${accessToken}`,
         Accept: "application/json",
       },
@@ -135,26 +201,18 @@ export async function discoverKimiModelMetadata(
     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");
-    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;
-    }
-    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;
+    const supportedIds = new Set([KIMI_CODING_MODEL_ID, KIMI_CODING_HIGHSPEED_MODEL_ID]);
+    const modelCatalog: Record<string, KimiModelMetadata> = {};
+    for (const model of list) {
+      if (typeof model.id !== "string" || !supportedIds.has(model.id)) continue;
+      const metadata = parseKimiModelMetadata(model);
+      if (metadata) modelCatalog[model.id] = metadata;
     }
-    if (typeof preferred.supports_video_in === "boolean") {
-      extras.supportsVideoIn = preferred.supports_video_in;
+    const preferred = modelCatalog[KIMI_CODING_MODEL_ID];
+    if (!preferred) {
+      return Object.keys(modelCatalog).length > 0 ? { modelCatalog } : {};
     }
-    return extras;
+    return { ...preferred, modelCatalog };
   } catch {
     return {};
   } finally {
@@ -162,12 +220,23 @@ export async function discoverKimiModelMetadata(
   }
 }
 
+export function getKimiModelMetadata(extras: KimiOAuthExtras, modelId: string): KimiModelMetadata {
+  const discovered = extras.modelCatalog?.[modelId];
+  if (discovered) return discovered;
+  return modelId === KIMI_CODING_MODEL_ID ? extras : {};
+}
+
 export function applyKimiOAuthExtrasToModel(
   model: Model<Api>,
-  extras: KimiOAuthExtras,
+  extras: KimiModelMetadata,
 ): Model<Api> {
-  const next: Model<Api> & { wireModelId?: string; supportsThinkingType?: "only" | "no" | "both" } =
-    { ...model };
+  const next: Model<Api> & {
+    wireModelId?: string;
+    supportsThinkingType?: "only" | "no" | "both";
+    wireProtocol?: KimiWireProtocol;
+    supportEfforts?: string[];
+    defaultEffort?: string;
+  } = { ...model };
   if (typeof extras.modelDisplay === "string" && extras.modelDisplay) {
     next.name = extras.modelDisplay;
     next.cost = resolveModelCost(extras.modelDisplay);
@@ -189,5 +258,8 @@ export function applyKimiOAuthExtrasToModel(
     const input = mergeInputModalities(next.input as KimiInputModality[], extras);
     (next as unknown as { input: string[] }).input = input;
   }
+  if (extras.protocol) next.wireProtocol = extras.protocol;
+  if (extras.supportEfforts) next.supportEfforts = [...extras.supportEfforts];
+  if (extras.defaultEffort) next.defaultEffort = extras.defaultEffort;
   return next;
 }

package/src/oauth.ts

@@ -2,9 +2,9 @@
 // reuse, the login / refresh handlers wired into pi's OAuth interface, and
 // the stream-level auth refresh used by the streaming handler.
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@earendil-works/pi-ai";
 import type { OAuthCredential } from "@earendil-works/pi-coding-agent";
@@ -123,6 +123,16 @@ interface RefreshAccessTokenOptions {
   sleep?: (ms: number) => Promise<void>;
 }
 
+export const KIMI_LOGIN_REQUIRED_MESSAGE =
+  "Kimi Code authorization is no longer valid. Sign in again with /login kimi-coding.";
+
+export class KimiLoginRequiredError extends Error {
+  constructor() {
+    super(KIMI_LOGIN_REQUIRED_MESSAGE);
+    this.name = "KimiLoginRequiredError";
+  }
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -152,8 +162,15 @@ export async function refreshAccessToken(
 
       if (!response.ok) {
         const text = await response.text().catch(() => "");
-        if (response.status === 401 || response.status === 403) {
-          throw new Error(`Token refresh unauthorized: ${text}`);
+        let errorCode = "";
+        try {
+          const body = JSON.parse(text) as { error?: unknown };
+          if (typeof body.error === "string") errorCode = body.error;
+        } catch {
+          // Non-JSON OAuth errors are classified by status below.
+        }
+        if (response.status === 401 || response.status === 403 || errorCode === "invalid_grant") {
+          throw new KimiLoginRequiredError();
         }
         if (RETRYABLE_REFRESH_STATUSES.has(response.status)) {
           throw new Error(`Token refresh retryable: ${response.status} ${text}`);
@@ -170,7 +187,7 @@ export async function refreshAccessToken(
     } catch (error) {
       lastError = error;
       const message = error instanceof Error ? error.message : String(error);
-      if (message.startsWith("Token refresh unauthorized:")) throw error;
+      if (error instanceof KimiLoginRequiredError) throw error;
       if (message.startsWith("Token refresh failed:")) throw error;
       if (attempt < maxRetries - 1) {
         await wait(2 ** attempt * 1000);
@@ -196,15 +213,19 @@ interface KimiCliCredentialsFile {
   access_token?: string;
   refresh_token?: string;
   expires_at?: number; // Unix seconds (upstream convention)
+  scope?: string;
+  token_type?: string;
+  expires_in?: number;
 }
 
-function getKimiCredentialPaths(): string[] {
+function getKimiCodeCredentialPath(): string {
   const kimiCodeHome = process.env.KIMI_CODE_HOME || join(os.homedir(), ".kimi-code");
+  return join(kimiCodeHome, "credentials", "kimi-code.json");
+}
+
+function getKimiCredentialPaths(): string[] {
   const shareDir = process.env.KIMI_SHARE_DIR || join(os.homedir(), ".kimi");
-  return [
-    join(kimiCodeHome, "credentials", "kimi-code.json"),
-    join(shareDir, "credentials", "kimi-code.json"),
-  ];
+  return [getKimiCodeCredentialPath(), join(shareDir, "credentials", "kimi-code.json")];
 }
 
 function readKimiCliCredentials(): KimiCliCredentialsFile | null {
@@ -221,6 +242,25 @@ function readKimiCliCredentials(): KimiCliCredentialsFile | null {
   return null;
 }
 
+function kimiCodeCredentialExists(): boolean {
+  return existsSync(getKimiCodeCredentialPath());
+}
+
+function writeKimiCodeCredentials(access: string, refresh: string, expiresMs: number): void {
+  const path = getKimiCodeCredentialPath();
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const data: KimiCliCredentialsFile = {
+    access_token: access,
+    refresh_token: refresh,
+    expires_at: Math.floor(expiresMs / 1000),
+    scope: "",
+    token_type: "Bearer",
+    expires_in: Math.max(0, Math.floor((expiresMs - Date.now()) / 1000)),
+  };
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+}
+
 async function tryReuseKimiCliCredentials(
   callbacks: OAuthLoginCallbacks,
 ): Promise<KimiOAuthCredentials | null> {
@@ -247,11 +287,13 @@ async function tryReuseKimiCliCredentials(
   callbacks.onProgress?.("Kimi access token expired, refreshing.");
   try {
     const token = await refreshAccessToken(data.refresh_token!);
+    const expiresMs = Date.now() + token.expires_in * 1000;
+    writeKimiCodeCredentials(token.access_token, token.refresh_token, expiresMs);
     const extras = await discoverKimiModelMetadata(token.access_token);
     return {
       access: token.access_token,
       refresh: token.refresh_token,
-      expires: Date.now() + token.expires_in * 1000,
+      expires: expiresMs,
       ...extras,
     };
   } catch {
@@ -319,11 +361,13 @@ export async function loginKimiCode(callbacks: OAuthLoginCallbacks): Promise<Kim
     }
 
     if (token) {
+      const expiresMs = Date.now() + token.expires_in * 1000;
+      writeKimiCodeCredentials(token.access_token, token.refresh_token, expiresMs);
       const extras = await discoverKimiModelMetadata(token.access_token);
       return {
         access: token.access_token,
         refresh: token.refresh_token,
-        expires: Date.now() + token.expires_in * 1000,
+        expires: expiresMs,
         ...extras,
       };
     }
@@ -335,12 +379,24 @@ export async function loginKimiCode(callbacks: OAuthLoginCallbacks): Promise<Kim
 export async function refreshKimiCodeToken(
   credentials: OAuthCredentials,
 ): Promise<KimiOAuthCredentials> {
-  const token = await refreshAccessToken(credentials.refresh);
+  const kimiCred = kimiCodeCredentialExists() ? readKimiCliCredentials() : null;
+  let token: Awaited<ReturnType<typeof refreshAccessToken>>;
+  try {
+    token = await refreshAccessToken(credentials.refresh);
+  } catch (error) {
+    if (kimiCred?.refresh_token && kimiCred.refresh_token !== credentials.refresh) {
+      token = await refreshAccessToken(kimiCred.refresh_token);
+    } else {
+      throw error;
+    }
+  }
+  const expiresMs = Date.now() + token.expires_in * 1000;
+  writeKimiCodeCredentials(token.access_token, token.refresh_token, expiresMs);
   const extras = await discoverKimiModelMetadata(token.access_token);
   return {
     access: token.access_token,
     refresh: token.refresh_token,
-    expires: Date.now() + token.expires_in * 1000,
+    expires: expiresMs,
     ...extras,
   };
 }
@@ -356,6 +412,10 @@ export async function refreshKimiCodeToken(
 // new credentials under a file lock), and retry once.
 // =============================================================================
 
+export function getKimiApiKey(credentials: OAuthCredentials): string {
+  return credentials.access;
+}
+
 export function isKimiAuthErrorMessage(message: unknown): boolean {
   const text = String(message ?? "").toLowerCase();
   return (
@@ -368,37 +428,79 @@ export function isKimiAuthErrorMessage(message: unknown): boolean {
 
 export async function refreshKimiAuthToken(currentKey: string): Promise<string | null> {
   try {
+    const kimiCred = readKimiCliCredentials();
     const storage = AuthStorage.create();
-    const cred = storage.get(PROVIDER_ID);
-    if (!cred || cred.type !== "oauth") {
+    const piCred = storage.get(PROVIDER_ID);
+    const piOAuth = piCred?.type === "oauth" ? piCred : null;
+
+    if (piOAuth) {
+      if (piOAuth.access !== currentKey && Date.now() < piOAuth.expires) {
+        console.error("[kimi-coding] auth refresh: reusing newer on-disk token");
+        return piOAuth.access;
+      }
+
+      console.error("[kimi-coding] auth refresh: requesting new access token");
+      let refreshed: Awaited<ReturnType<typeof refreshAccessToken>>;
+      try {
+        refreshed = await refreshAccessToken(piOAuth.refresh);
+      } catch (error) {
+        if (!kimiCred?.refresh_token || kimiCred.refresh_token === piOAuth.refresh) throw error;
+        const kimiExpiresMs = (kimiCred.expires_at ?? 0) * 1000;
+        if (kimiCred.access_token !== currentKey && Date.now() < kimiExpiresMs) {
+          const recovered: OAuthCredential = {
+            ...piOAuth,
+            type: "oauth",
+            access: kimiCred.access_token!,
+            refresh: kimiCred.refresh_token,
+            expires: kimiExpiresMs,
+          };
+          storage.set(PROVIDER_ID, recovered);
+          console.error("[kimi-coding] auth refresh: recovered newer kimi-code token");
+          return recovered.access;
+        }
+        console.error("[kimi-coding] auth refresh: pi token rejected, trying kimi-code token");
+        refreshed = await refreshAccessToken(kimiCred.refresh_token);
+      }
+
+      const newExpiresMs = Date.now() + refreshed.expires_in * 1000;
+      const newCred: OAuthCredential = {
+        ...piOAuth,
+        type: "oauth",
+        access: refreshed.access_token,
+        refresh: refreshed.refresh_token,
+        expires: newExpiresMs,
+      };
+      storage.set(PROVIDER_ID, newCred);
+      writeKimiCodeCredentials(refreshed.access_token, refreshed.refresh_token, newExpiresMs);
+      console.error("[kimi-coding] auth refresh: new token persisted");
+      return newCred.access;
+    }
+
+    if (!kimiCred) {
       console.error(
         `[kimi-coding] auth refresh skipped: no OAuth credentials for ${PROVIDER_ID} on disk`,
       );
       return null;
     }
 
-    // If disk already has a different valid token (e.g., another process or a
-    // previous retry refreshed it while the caller's in-memory cache went
-    // stale), reuse it without hitting the OAuth endpoint.
-    if (cred.access !== currentKey && Date.now() < cred.expires) {
-      console.error("[kimi-coding] auth refresh: reusing newer on-disk token");
-      return cred.access;
+    const kimiExpiresMs = (kimiCred.expires_at ?? 0) * 1000;
+    if (kimiCred.access_token !== currentKey && Date.now() < kimiExpiresMs) {
+      console.error("[kimi-coding] auth refresh: reusing newer kimi-code token");
+      return kimiCred.access_token!;
     }
 
-    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,
-      expires: Date.now() + refreshed.expires_in * 1000,
-    };
-    storage.set(PROVIDER_ID, newCred);
-    console.error("[kimi-coding] auth refresh: new token persisted");
-    return newCred.access;
+    console.error("[kimi-coding] auth refresh: requesting new access token via kimi-code");
+    const refreshed = await refreshAccessToken(kimiCred.refresh_token!);
+    const newExpiresMs = Date.now() + refreshed.expires_in * 1000;
+    writeKimiCodeCredentials(refreshed.access_token, refreshed.refresh_token, newExpiresMs);
+    console.error("[kimi-coding] auth refresh: new token persisted to kimi-code");
+    return refreshed.access_token;
   } catch (err) {
-    console.error("[kimi-coding] auth refresh failed:", err);
+    if (err instanceof KimiLoginRequiredError) {
+      console.error(`[kimi-coding] ${KIMI_LOGIN_REQUIRED_MESSAGE}`);
+    } else {
+      console.error("[kimi-coding] auth refresh failed:", err);
+    }
     return null;
   }
 }

package/src/payload.ts

@@ -6,7 +6,7 @@ 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 { getKimiProviderHeaders } from "./device.ts";
 import { optimizeToolSchemas } from "./schema-dedup.ts";
 
 // =============================================================================
@@ -116,7 +116,7 @@ export async function uploadKimiFile(
   try {
     const response = await fetch(uploadUrl, {
       method: "POST",
-      headers: { Authorization: `Bearer ${apiKey}`, ...getCommonHeaders() },
+      headers: { ...getKimiProviderHeaders(), Authorization: `Bearer ${apiKey}` },
       body: formData,
     });
     if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
@@ -425,7 +425,19 @@ export async function applyKimiPayloadMutations(
       : { include_usage: true };
   }
 
-  // 5. Normalize deprecated max_tokens (OpenAI path only — Anthropic
+  // 5. Spread extra_body into the top-level payload before normalization and
+  //    config caps. Top-level fields retain precedence over extra_body.
+  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;
+      }
+    }
+  }
+
+  // 6. 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") {
@@ -438,44 +450,45 @@ export async function applyKimiPayloadMutations(
   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;
+    const maxTokensKey = ctx.api === "anthropic-messages" ? "max_tokens" : "max_completion_tokens";
+    const currentMaxTokens = payload[maxTokensKey];
+    payload[maxTokensKey] =
+      typeof currentMaxTokens === "number"
+        ? Math.min(currentMaxTokens, generation.maxCompletionTokens)
+        : generation.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;
-      }
-    }
+  // 7. Reasoning effort mapping. Kimi now accepts effort only inside the
+  //    thinking object, and only for values advertised by the model catalog.
+  delete payload.reasoning_effort;
+  if (ctx.modelConfig.supportsThinkingType === "no") {
+    delete payload.thinking;
   }
-
-  // 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) {
-      if (mapped.effort !== null) {
-        payload.reasoning_effort = mapped.effort;
-      } else {
-        delete payload.reasoning_effort;
-      }
       const oldThinking = isRecord(payload.thinking) ? payload.thinking : {};
-      payload.thinking = {
+      const thinking: JsonRecord = {
         ...oldThinking,
         type: mapped.enabled ? "enabled" : "disabled",
       };
+      delete thinking.effort;
+      if (!mapped.enabled) delete thinking.keep;
+      const effort = ctx.reasoning
+        ? mapped.effort
+        : (ctx.modelConfig.defaultEffort ?? mapped.effort);
+      if (mapped.enabled && effort !== null && ctx.modelConfig.supportEfforts?.includes(effort)) {
+        thinking.effort = effort;
+      }
       if (mapped.enabled && ctx.modelConfig.thinkingKeep) {
-        (payload.thinking as JsonRecord).keep = ctx.modelConfig.thinkingKeep;
+        thinking.keep = ctx.modelConfig.thinkingKeep;
       }
+      payload.thinking = thinking;
     }
   }
 
-  // 7. K2.7 Code API constraints: the server rejects non-default values for
+  // 8. 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) {

package/src/stream.ts

@@ -24,7 +24,7 @@ import {
 } from "./config.ts";
 
 import { ENV_KIMI_CODE_PROTOCOL, getApiProtocol, getBaseUrl } from "./constants.ts";
-import { getCommonHeaders } from "./device.ts";
+import { getKimiProviderHeaders } from "./device.ts";
 import { isKimiAuthErrorMessage, refreshKimiAuthToken } from "./oauth.ts";
 import {
   type Uploader,
@@ -163,7 +163,7 @@ export function resolveKimiApiKey(apiKey: string | undefined): string {
 }
 
 export function mergeKimiRequestHeaders(headers?: Record<string, string>): Record<string, string> {
-  return { ...getCommonHeaders(), ...headers };
+  return { ...getKimiProviderHeaders(), ...headers };
 }
 
 export function streamSimpleKimi(
@@ -192,8 +192,27 @@ export function streamSimpleKimi(
     protocol: ENV_KIMI_CODE_PROTOCOL,
     uploads: DEFAULT_KIMI_CODE_CONFIG.uploads,
   };
-  const modelConfig = streamConfig.model;
-  const apiProtocol = getApiProtocol(streamConfig.protocol);
+  const discoveredModel = model as Model<Api> & {
+    supportsThinkingType?: "only" | "no" | "both";
+    wireProtocol?: KimiCodeConfig["protocol"];
+    supportEfforts?: string[];
+    defaultEffort?: string;
+  };
+  const modelConfig: KimiResolvedModelConfig = {
+    ...streamConfig.model,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    input: [...model.input],
+    reasoning: model.reasoning,
+    supportsThinkingType:
+      discoveredModel.supportsThinkingType ?? (model.reasoning ? undefined : "no"),
+    supportEfforts: discoveredModel.supportEfforts
+      ? [...discoveredModel.supportEfforts]
+      : undefined,
+    defaultEffort: discoveredModel.defaultEffort,
+  };
+  const wireProtocol = discoveredModel.wireProtocol ?? streamConfig.protocol;
+  const apiProtocol = getApiProtocol(wireProtocol);
   const originalOnPayload = options?.onPayload;
   // The pi-side model id ("kimi-for-coding") is what users select via /model
   // and what gets persisted into sessions. The wire model id discovered at
@@ -257,10 +276,10 @@ export function streamSimpleKimi(
       const runtimeModel = {
         ...model,
         api: apiProtocol,
-        baseUrl: getBaseUrl(streamConfig.protocol),
+        baseUrl: getBaseUrl(wireProtocol),
       } as Model<Api>;
       const upstream =
-        streamConfig.protocol === "openai"
+        wireProtocol === "openai"
           ? streamSimpleOpenAICompletions(
               runtimeModel as Model<"openai-completions">,
               context,

package/src/tools/common.ts

@@ -2,8 +2,8 @@ import { AuthStorage, type AgentToolResult } from "@earendil-works/pi-coding-age
 import { truncateToWidth } from "@earendil-works/pi-tui";
 
 import { PROVIDER_ID, getBaseUrl } from "../constants.ts";
-import { getCommonHeaders } from "../device.ts";
-import { refreshKimiAuthToken } from "../oauth.ts";
+import { getKimiProviderHeaders } from "../device.ts";
+import { KIMI_LOGIN_REQUIRED_MESSAGE, refreshKimiAuthToken } from "../oauth.ts";
 
 export const KIMI_TOOL_TIMEOUT_MS = 180_000;
 
@@ -67,7 +67,7 @@ export function getKimiDatasourceUrl(): string {
 
 export function buildHeaders(accessToken: string, toolCallId: string): Record<string, string> {
   return {
-    ...getCommonHeaders(),
+    ...getKimiProviderHeaders(),
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json",
     "X-Msh-Tool-Call-Id": toolCallId,
@@ -94,7 +94,9 @@ export async function fetchWithAuthRetry(
   if (response.status !== 401) return response;
 
   const refreshed = await deps.refreshAccessToken(accessToken);
-  if (!refreshed || refreshed === accessToken) return response;
+  if (!refreshed || refreshed === accessToken) {
+    throw new Error(KIMI_LOGIN_REQUIRED_MESSAGE);
+  }
   return request(refreshed);
 }
 

package/src/tools/moonshot.ts

@@ -17,20 +17,6 @@ import {
 
 export const moonshotSearchSchema = Type.Object({
   query: Type.String({ description: "The query text to search for." }),
-  limit: Type.Optional(
-    Type.Number({
-      description: "The number of results to return.",
-      default: 5,
-      minimum: 1,
-      maximum: 20,
-    }),
-  ),
-  include_content: Type.Optional(
-    Type.Boolean({
-      description: "Whether to include fetched page content in the search results.",
-      default: false,
-    }),
-  ),
 });
 
 export const moonshotFetchSchema = Type.Object({
@@ -44,7 +30,8 @@ export interface MoonshotSearchResult {
   url: string;
   title: string;
   snippet: string;
-  content?: string;
+  date?: string;
+  siteName?: string;
 }
 
 export interface MoonshotFetchResult {
@@ -52,11 +39,6 @@ export interface MoonshotFetchResult {
   content: string;
 }
 
-function clampLimit(value: number | undefined): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) return 5;
-  return Math.max(1, Math.min(20, Math.trunc(value)));
-}
-
 interface MoonshotSearchResponse {
   search_results?: unknown;
 }
@@ -66,7 +48,7 @@ function stringField(record: Record<string, unknown>, key: string): string {
   return typeof value === "string" ? value : "";
 }
 
-function mapSearchResults(value: unknown, includeContent: boolean): MoonshotSearchResult[] {
+function mapSearchResults(value: unknown): MoonshotSearchResult[] {
   if (!Array.isArray(value)) return [];
   return value
     .filter((item): item is Record<string, unknown> => typeof item === "object" && item !== null)
@@ -76,9 +58,10 @@ function mapSearchResults(value: unknown, includeContent: boolean): MoonshotSear
         title: stringField(item, "title"),
         snippet: stringField(item, "snippet"),
       };
-      if (includeContent) {
-        result.content = stringField(item, "content");
-      }
+      const date = stringField(item, "date");
+      if (date) result.date = date;
+      const siteName = stringField(item, "site_name");
+      if (siteName) result.siteName = siteName;
       return result;
     });
 }
@@ -130,8 +113,10 @@ export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
   return defineTool({
     name: "moonshot_search",
     label: "Moonshot Search",
-    description: "Search the web through Kimi Coding's server-side Moonshot search service.",
-    promptSnippet: "Search the web with Kimi Coding's Moonshot search service",
+    description:
+      "Search the web through Kimi Coding. Results are summaries; use moonshot_fetch to read relevant pages.",
+    promptSnippet:
+      "Search the web with Kimi Coding, then fetch the few relevant result URLs before answering",
     parameters: moonshotSearchSchema,
 
     async execute(toolCallId, params, signal) {
@@ -142,20 +127,13 @@ export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
         );
       }
 
-      const limit = clampLimit(params.limit);
-      const includeContent = params.include_content === true;
       const timeout = buildTimeoutSignal(signal);
       try {
         const response = await fetchWithAuthRetry(deps, accessToken, (token) =>
           deps.fetch(`${getKimiBaseV1()}/search`, {
             method: "POST",
             headers: buildHeaders(token, toolCallId),
-            body: JSON.stringify({
-              text_query: params.query,
-              limit,
-              enable_page_crawling: includeContent,
-              timeout_seconds: 30,
-            }),
+            body: JSON.stringify({ text_query: params.query }),
             signal: timeout.signal,
           }),
         );
@@ -168,7 +146,7 @@ export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
         }
 
         const data = (await response.json()) as MoonshotSearchResponse;
-        const results = mapSearchResults(data.search_results, includeContent);
+        const results = mapSearchResults(data.search_results);
         return {
           content: [{ type: "text", text: searchResultsText(results) }],
           details: results,

package/src/usage.ts

@@ -1,7 +1,7 @@
 import { AuthStorage } from "@earendil-works/pi-coding-agent";
 
 import { PROVIDER_ID, getBaseUrl } from "./constants.ts";
-import { getCommonHeaders } from "./device.ts";
+import { getKimiProviderHeaders } from "./device.ts";
 import { refreshKimiAuthToken } from "./oauth.ts";
 
 const MEMBERSHIP_LEVEL_NAMES: Record<string, string> = {
@@ -36,6 +36,16 @@ export interface UsageFormatOptions {
   timeZone?: string;
 }
 
+interface BoosterWalletInfo {
+  balanceCents: bigint;
+  monthlyChargeLimitEnabled: boolean;
+  monthlyChargeLimitCents: bigint;
+  monthlyUsedCents: bigint;
+  currency: string;
+}
+
+const FIXED_POINT_CENTS = 1_000_000n;
+
 export function getKimiUsageToken(): string | null {
   const credential = AuthStorage.create().get(PROVIDER_ID);
   if (credential?.type === "oauth" && credential.access) return credential.access;
@@ -62,6 +72,82 @@ function getResetTime(record: Record<string, unknown>): string | undefined {
   return undefined;
 }
 
+function toBigInt(value: unknown): bigint | null {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "string" && /^-?\d+$/.test(value)) return BigInt(value);
+  if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+  return null;
+}
+
+function fixedPointToCents(value: bigint): bigint {
+  if (value > 0n && value < FIXED_POINT_CENTS) return 1n;
+  return (value + FIXED_POINT_CENTS / 2n) / FIXED_POINT_CENTS;
+}
+
+function parseMoney(value: unknown): { cents: bigint; currency: string } | null {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value as Record<string, unknown>;
+  const cents = toBigInt(record.priceInCents);
+  if (cents === null) return null;
+  return {
+    cents,
+    currency: typeof record.currency === "string" ? record.currency : "",
+  };
+}
+
+function parseBoosterWallet(value: unknown): BoosterWalletInfo | null {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value as Record<string, unknown>;
+  const balance = record.balance;
+  if (typeof balance !== "object" || balance === null || Array.isArray(balance)) return null;
+  const balanceRecord = balance as Record<string, unknown>;
+  if (balanceRecord.type !== "BOOSTER") return null;
+  const amount = toBigInt(balanceRecord.amount);
+  if (amount === null || amount < 0n) return null;
+
+  const amountLeft = toBigInt(balanceRecord.amountLeft);
+  const monthlyLimit = parseMoney(record.monthlyChargeLimit);
+  const monthlyUsed = parseMoney(record.monthlyUsed);
+  return {
+    balanceCents: amountLeft === null ? 0n : fixedPointToCents(amountLeft),
+    monthlyChargeLimitEnabled: record.monthlyChargeLimitEnabled === true,
+    monthlyChargeLimitCents: monthlyLimit?.cents ?? 0n,
+    monthlyUsedCents: monthlyUsed?.cents ?? 0n,
+    currency: monthlyLimit?.currency || monthlyUsed?.currency || "USD",
+  };
+}
+
+function formatCurrency(cents: bigint, currency: string): string {
+  const symbol =
+    currency.toUpperCase() === "USD" ? "$" : currency.toUpperCase() === "CNY" ? "¥" : "";
+  const sign = cents < 0n ? "-" : "";
+  const absolute = cents < 0n ? -cents : cents;
+  const amount = `${sign}${absolute / 100n}.${String(absolute % 100n).padStart(2, "0")}`;
+  return symbol ? `${symbol}${amount}` : `${amount} ${currency}`.trim();
+}
+
+function formatExtraUsage(info: BoosterWalletInfo): string[] {
+  const hasMonthlyLimit = info.monthlyChargeLimitEnabled && info.monthlyChargeLimitCents > 0n;
+  const lines = ["Extra Usage"];
+  if (hasMonthlyLimit) {
+    const used =
+      info.monthlyUsedCents < info.monthlyChargeLimitCents
+        ? info.monthlyUsedCents
+        : info.monthlyChargeLimitCents;
+    const percent = Number(
+      (used * 100n + info.monthlyChargeLimitCents / 2n) / info.monthlyChargeLimitCents,
+    );
+    const barUnits = Number((used * 400n) / info.monthlyChargeLimitCents);
+    lines.push(`${quotaBar(barUnits, 400)} ${percent}% used`);
+  }
+  lines.push(`Used this month: ${formatCurrency(info.monthlyUsedCents, info.currency)}`);
+  lines.push(
+    `Monthly limit: ${hasMonthlyLimit ? formatCurrency(info.monthlyChargeLimitCents, info.currency) : "Unlimited"}`,
+  );
+  lines.push(`Balance: ${formatCurrency(info.balanceCents, info.currency)}`);
+  return lines;
+}
+
 export function parseUsageRow(value: unknown, fallbackLabel: string): UsageRow | null {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
@@ -115,6 +201,12 @@ export function parseUsageSummary(payload: unknown, options: UsageFormatOptions
     }
   }
 
+  const extraUsage = parseBoosterWallet(record.boosterWallet);
+  if (extraUsage) {
+    if (lines.length > 0) lines.push("");
+    lines.push(...formatExtraUsage(extraUsage));
+  }
+
   while (lines.at(-1) === "") lines.pop();
   return lines.length === 0 ? "Usage: no usage data" : lines.join("\n");
 }
@@ -244,7 +336,7 @@ function fetchKimiUsage(token: string, signal: AbortSignal): Promise<Response> {
   return fetch(buildKimiUsageUrl(), {
     method: "GET",
     headers: {
-      ...getCommonHeaders(),
+      ...getKimiProviderHeaders(),
       Authorization: `Bearer ${token}`,
     },
     signal,