pi-provider-kimi-code 0.6.3 → 0.6.6

package/README.md

@@ -7,7 +7,7 @@
 
 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, tool schema compatibility, live model metadata, measured cache behavior, and API-tested parameter handling.
 
-> **Kimi K2.7 supported.** The provider automatically discovers the current model from Kimi's `/v1/models` endpoint at login, refresh, and `/kimi-settings` time, so new rollouts (including K2.7) are picked up immediately without a package update.
+> **Kimi K3 supported.** The provider combines Kimi's live `/v1/models` catalog with your membership level from `/usages`, exposing only eligible models and advertising the correct K3 context limit. It refreshes this metadata at startup and through `/kimi-settings`; OAuth login and token refresh also update the model catalog.
 
 ## Why this exists
 
@@ -19,20 +19,20 @@ Kimi's API surface goes beyond the LLM itself. It includes file uploads, web sea
 - **Send files the Kimi way.** Large inline images go through Kimi's Files API and become `ms://` references instead of huge base64 payloads.
 - **Know what the cache is doing.** Kimi caches by content prefix. This repo measures that behavior instead of pretending `prompt_cache_key` controls it.
 - **Keep Pi's tools working.** Moonshot's API rejects tool schemas over 15 KB — a limit that Pi's extension ecosystem regularly hits ([#16](https://github.com/Leechael/pi-provider-kimi-code/issues/16), [#21](https://github.com/Leechael/pi-provider-kimi-code/issues/21)). This extension automatically deduplicates schemas with `$ref`/`$defs` before sending, so subagents and other extensions don't break.
-- **Tested against the live API.** Thinking config, parameter constraints, protocol compatibility, and streaming behavior are all verified against Kimi's Coding endpoint — not assumed from docs. When the API rejects something (wrong `temperature`, unsupported `tool_choice`), the provider strips it before you see a 400.
+- **Tested against the live API.** Thinking config, parameter constraints, protocol compatibility, and streaming behavior are all verified against Kimi's Coding endpoint — not assumed from docs. When the API rejects something (wrong `temperature`, unsupported `tool_choice`), the provider normalizes the request before you see a 400.
 - **Turn on Kimi-native tools when you want them.** `moonshot_search`, `moonshot_fetch`, and `kimi_datasource` are opt-in, configurable per user or per project.
 - **Embed in your own build.** `KimiCode()` factory lets you ship Kimi Code support inside a custom Pi agent with programmatic config overrides — no file-based extension path needed.
 
 ## What this package adds
 
 - Kimi account login in Pi, plus `KIMI_API_KEY` for CI or pay-per-token use.
-- `kimi-code` credential reuse from `~/.kimi/credentials/kimi-code.json`.
+- `kimi-code` credential reuse from `~/.kimi-code/credentials/kimi-code.json`, with read-only support for the legacy `~/.kimi` path.
 - Kimi Files API uploads for large inline images.
-- Live model metadata from Kimi at login, refresh, and `/kimi-settings` time.
+- Live model metadata combined with membership-aware K3 and HighSpeed availability.
 - OpenAI-compatible mode by default, Anthropic-compatible mode on request.
-- Kimi K2.7 reasoning level mapping for Pi's reasoning controls.
+- K2.7 and K3 reasoning level mapping for Pi's reasoning controls.
 - Tool schema dedup to stay under Moonshot's 15 KB per-tool-schema limit.
-- K2.7 parameter guard: strips `temperature`, `top_p`, and `tool_choice` values that the API rejects.
+- K2.7 parameter guard: removes rejected `temperature` and `top_p` values and rewrites unsupported `tool_choice` values to `auto`.
 - Stream cleanup for Kimi's thinking-only placeholder text.
 - Optional `moonshot_search`, `moonshot_fetch`, and unified datasource `kimi_datasource` tools via `/kimi-settings`.
 - Programmatic `KimiCode()` factory for embedding in custom Pi builds.
@@ -84,15 +84,21 @@ Inside Pi, run:
 /login kimi-coding
 ```
 
-A browser tab opens, you sign into your Kimi account, and Pi stores the credential at `~/.pi/agent/auth.json`. Tokens refresh automatically.
+A browser tab opens, you sign into your Kimi account, and Pi stores the credential at `~/.pi/agent/auth.json`. Tokens refresh automatically. The extension also syncs refreshed credentials to the current `kimi-code` credential file:
 
-If you already use `kimi-code`, this extension can reuse its credential file:
+```text
+~/.kimi-code/credentials/kimi-code.json
+```
+
+If you already use `kimi-code`, the extension can reuse that session. Set `KIMI_CODE_HOME` if its home directory lives somewhere else.
+
+The legacy credential path is also supported:
 
 ```text
 ~/.kimi/credentials/kimi-code.json
 ```
 
-The file is read-only from this extension's side. Set `KIMI_SHARE_DIR` if your `kimi-code` share directory lives somewhere else.
+Legacy credentials are read-only. Set `KIMI_SHARE_DIR` to override the legacy `~/.kimi` directory.
 
 For CI or pay-per-token use, set `KIMI_API_KEY` instead:
 
@@ -100,18 +106,24 @@ For CI or pay-per-token use, set `KIMI_API_KEY` instead:
 KIMI_API_KEY=sk-... pi
 ```
 
-## Model
+## Models
 
-This provider publishes one Pi model ID:
+This provider publishes three Pi model IDs:
 
-```text
-kimi-coding/kimi-for-coding
-```
+| Pi model ID                             | Upstream model           | Access                                                 |
+| --------------------------------------- | ------------------------ | ------------------------------------------------------ |
+| `kimi-coding/kimi-for-coding`           | Kimi K2.7 Code           | All Kimi Code members                                  |
+| `kimi-coding/kimi-for-coding-highspeed` | Kimi K2.7 Code HighSpeed | Allegretto and above                                   |
+| `kimi-coding/k3`                        | Kimi K3                  | Moderato: 256K context; Allegretto and above: up to 1M |
 
-Select it inside Pi:
+Plans below Moderato cannot use K3. The provider reads the current membership level from `/usages` and combines it with `/models`: server catalog availability remains authoritative, while known plan limits can only hide unavailable selections or lower K3's advertised context window. Unknown or unavailable membership data falls back to the server catalog instead of guessing.
+
+Select a model inside Pi:
 
 ```text
 /model kimi-coding/kimi-for-coding
+/model kimi-coding/kimi-for-coding-highspeed
+/model kimi-coding/k3
 ```
 
 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 +135,9 @@ 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. K3 currently advertises only `max`; `max` and `xhigh` map to `max`, `high` and `medium` map to `high`, and `low` and `minimal` map to `low`. It sends `thinking.effort` only when `/models` advertises the mapped value. The mapping refreshes automatically on credential refresh. Opening `/kimi-settings` also re-discovers the latest model and membership metadata.
+
+Switching models or thinking effort invalidates Kimi's existing context cache. Start a new session when switching to avoid re-prefilling a long conversation and consuming extra quota.
 
 ## Optional tools
 
@@ -135,14 +149,14 @@ 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.
 
 Config files are JSON:
 
-- Home: `~/.pi/pi-provider-kimi-code.json`
-- Project override: `<cwd>/.pi/pi-provider-kimi-code.json`
+- Home: `~/.pi/providers/kimi-coding/config.json`
+- Project override: `<cwd>/.pi/providers/kimi-coding/config.json`
 
 Project config overrides home config with a deep merge. Missing files or missing keys mean all tools stay off.
 
@@ -277,7 +291,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
 
@@ -294,7 +308,7 @@ In OpenAI mode this extension maps the `developer` role to `system` (Kimi's Codi
 
 ## Credits
 
-Based on the login implementation from Kimi Code by Moonshot AI. Built as a Pi extension by [@badlogic](https://github.com/badlogic).
+Based on the login implementation from Kimi Code by Moonshot AI. Pi was originally created by [@badlogic](https://github.com/badlogic).
 
 ## License
 

package/index.ts

@@ -42,12 +42,19 @@ import { PROVIDER_ID, PROVIDER_VERSION, getBaseUrl, getKimiApiType } from "./src
 import {
   type KimiOAuthCredentials,
   type KimiOAuthExtras,
+  applyKimiMembershipLimitsToModel,
   buildKimiModelFromConfig,
   applyKimiOAuthExtrasToModel,
+  KIMI_CODING_HIGHSPEED_MODEL_ID,
+  KIMI_CODING_MODEL_ID,
+  KIMI_K3_MODEL_ID,
+  KIMI_MODEL_CATALOG_VERSION,
   discoverKimiModelMetadata,
+  getKimiModelMetadata,
+  isKimiModelAvailableForMembership,
   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,
@@ -57,13 +64,14 @@ import {
   parseByteSizeInput,
 } from "./src/settings-ui.ts";
 import { setStoreResolvedKimiConfig, streamSimpleKimi } from "./src/stream.ts";
-import { fetchKimiUsageSummary, getKimiUsageToken } from "./src/usage.ts";
+import { fetchKimiUsageSnapshot, getKimiUsageToken } from "./src/usage.ts";
 import { buildMoonshotFetchTool, buildMoonshotSearchTool } from "./src/tools/moonshot.ts";
 import { buildKimiDatasourceTool } from "./src/tools/datasource.ts";
 interface KimiRuntimeState {
   cwd: string;
   config: KimiCodeConfig;
   modelExtras: KimiOAuthExtras;
+  membershipLevel: string | null;
   projectTrusted: boolean;
   overrides?: KimiCodeConfigPatch;
 }
@@ -114,7 +122,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 +143,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 +157,21 @@ async function openSettingsMenu(
   ctx: ExtensionCommandContext,
   state: KimiRuntimeState,
 ): Promise<void> {
-  const [usage] = await Promise.all([fetchKimiUsageSummary(), refreshModelExtras(state)]);
+  const modelDiscoveryToken = getKimiUsageToken();
+  const [usageSnapshot, initialModelsRefreshed] = await Promise.all([
+    fetchKimiUsageSnapshot(),
+    refreshModelExtras(state),
+  ]);
+  let modelsRefreshed = initialModelsRefreshed;
+  const refreshedToken = getKimiUsageToken();
+  if (!modelsRefreshed && refreshedToken && refreshedToken !== modelDiscoveryToken) {
+    modelsRefreshed = await refreshModelExtras(state);
+  }
+  const refreshedMembershipLevel = usageSnapshot.membershipLevel ?? state.membershipLevel;
+  const membershipChanged = state.membershipLevel !== refreshedMembershipLevel;
+  state.membershipLevel = refreshedMembershipLevel;
+  if (modelsRefreshed || membershipChanged) registerKimiProvider(pi, state);
+  const usage = usageSnapshot.summary;
 
   const projectTrusted = await isKimiProjectConfigApproved(ctx, ctx.cwd);
   const homeDraft = loadHomeKimiCodeConfig(os.homedir());
@@ -354,10 +379,43 @@ function saveScopeKimiCodeConfig(
   }
 }
 
+function filterAvailableKimiModels<T extends { id: string }>(
+  models: T[],
+  extras: KimiOAuthExtras,
+  membershipLevel: string | null,
+): T[] {
+  const available =
+    extras.modelCatalogVersion === KIMI_MODEL_CATALOG_VERSION && extras.modelCatalog
+      ? new Set(Object.keys(extras.modelCatalog))
+      : null;
+  return models.filter(
+    (model) =>
+      (!available || available.has(model.id)) &&
+      isKimiModelAvailableForMembership(model.id, membershipLevel) !== false,
+  );
+}
+
 function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
-  const model = applyKimiOAuthExtrasToModel(
-    buildKimiModelFromConfig(state.config.model),
-    state.modelExtras,
+  const standardModel = applyKimiMembershipLimitsToModel(
+    applyKimiOAuthExtrasToModel(
+      buildKimiModelFromConfig(state.config.model),
+      getKimiModelMetadata(state.modelExtras, KIMI_CODING_MODEL_ID),
+    ),
+    state.membershipLevel,
+  );
+  const highSpeedModel = applyKimiMembershipLimitsToModel(
+    applyKimiOAuthExtrasToModel(
+      buildKimiModelFromConfig(state.config.model, KIMI_CODING_HIGHSPEED_MODEL_ID),
+      getKimiModelMetadata(state.modelExtras, KIMI_CODING_HIGHSPEED_MODEL_ID),
+    ),
+    state.membershipLevel,
+  );
+  const k3Model = applyKimiMembershipLimitsToModel(
+    applyKimiOAuthExtrasToModel(
+      buildKimiModelFromConfig(state.config.model, KIMI_K3_MODEL_ID),
+      getKimiModelMetadata(state.modelExtras, KIMI_K3_MODEL_ID),
+    ),
+    state.membershipLevel,
   );
 
   pi.registerProvider(PROVIDER_ID, {
@@ -366,13 +424,35 @@ function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
     api: getKimiApiType(state.config.protocol),
     streamSimple: streamSimpleKimi,
 
-    models: [model],
+    models: filterAvailableKimiModels(
+      [standardModel, highSpeedModel, k3Model],
+      state.modelExtras,
+      state.membershipLevel,
+    ),
 
     oauth: {
       name: "Kimi Code (OAuth)",
-      login: loginKimiCode,
-      refreshToken: refreshKimiCodeToken,
-      getApiKey: (cred) => cred.access,
+      login: async (callbacks) => {
+        const credentials = await loginKimiCode(callbacks);
+        const usage = await fetchKimiUsageSnapshot({
+          timeoutMs: 2500,
+          token: credentials.access,
+          refreshOnUnauthorized: false,
+        });
+        state.membershipLevel = usage.membershipLevel;
+        return credentials;
+      },
+      refreshToken: async (credentials) => {
+        const refreshed = await refreshKimiCodeToken(credentials);
+        const usage = await fetchKimiUsageSnapshot({
+          timeoutMs: 2500,
+          token: refreshed.access,
+          refreshOnUnauthorized: false,
+        });
+        state.membershipLevel = usage.membershipLevel;
+        return refreshed;
+      },
+      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 +462,25 @@ 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.modelCatalogVersion === KIMI_MODEL_CATALOG_VERSION && extras.modelCatalog
+            ? new Set(Object.keys(extras.modelCatalog))
+            : null;
+        return models
+          .filter(
+            (model) =>
+              model.provider !== PROVIDER_ID ||
+              ((!available || available.has(model.id)) &&
+                isKimiModelAvailableForMembership(model.id, state.membershipLevel) !== false),
+          )
+          .map((model) =>
+            model.provider === PROVIDER_ID
+              ? applyKimiMembershipLimitsToModel(
+                  applyKimiOAuthExtrasToModel(model, getKimiModelMetadata(extras, model.id)),
+                  state.membershipLevel,
+                )
+              : model,
+          );
       },
     },
   });
@@ -399,13 +494,24 @@ export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
       overrides,
     );
     const discoveryToken = getKimiUsageToken();
-    const discovered = discoveryToken
-      ? await discoverKimiModelMetadata(discoveryToken, config.protocol)
-      : {};
+    const [initialDiscovery, usageSnapshot] = await Promise.all([
+      discoveryToken ? discoverKimiModelMetadata(discoveryToken, config.protocol) : {},
+      fetchKimiUsageSnapshot({ timeoutMs: 2500 }),
+    ]);
+    let discovered = initialDiscovery;
+    const refreshedToken = getKimiUsageToken();
+    if (
+      Object.keys(discovered).length === 0 &&
+      refreshedToken &&
+      refreshedToken !== discoveryToken
+    ) {
+      discovered = await discoverKimiModelMetadata(refreshedToken, config.protocol);
+    }
     const state: KimiRuntimeState = {
       cwd,
       config,
       modelExtras: discovered,
+      membershipLevel: usageSnapshot.membershipLevel,
       projectTrusted: false,
       overrides,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.3",
+  "version": "0.6.6",
   "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 {
@@ -119,9 +121,10 @@ export const DEFAULT_KIMI_CODE_CONFIG: KimiCodeConfig = {
       off: { effort: null, enabled: false },
       minimal: { effort: "low", enabled: true },
       low: { effort: "low", enabled: true },
-      medium: { effort: "medium", enabled: true },
+      medium: { effort: "high", enabled: true },
       high: { effort: "high", enabled: true },
-      xhigh: { effort: "high", enabled: true },
+      xhigh: { effort: "max", enabled: true },
+      max: { effort: "max", enabled: true },
     },
     thinkingKeep: "all",
     generation: {},

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.6";
 
 // 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";
+// syncing with https://github.com/MoonshotAI/kimi-code.
+export const KIMI_UPSTREAM_VERSION = "0.26.0";
 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() };
+}