pi-provider-kimi-code 0.6.8 → 0.6.10

package/README.md

@@ -3,40 +3,29 @@
 [![npm](https://img.shields.io/npm/v/pi-provider-kimi-code)](https://www.npmjs.com/package/pi-provider-kimi-code)
 [![license](https://img.shields.io/npm/l/pi-provider-kimi-code)](./LICENSE)
 
-**Use Kimi Code in Pi, with the Kimi parts handled.**
-
-Pi already has a basic `kimi-coding` provider. This extension is for the parts that start to matter once Kimi Code becomes part of your real Pi workflow: account login reuse, file uploads, tool schema compatibility, live model metadata, measured cache behavior, and API-tested parameter handling.
-
-> **Kimi K3 supported.** The provider reads Kimi's live `/v1/models` catalog as the source of truth for model availability and context limits. It refreshes the catalog at startup and through `/kimi-settings`; OAuth login and token refresh also update it.
+> **Kimi Code extension for Pi — use K3, K2.7 Code, and HighSpeed models with your Kimi Code Plan.** This extension brings the full Kimi Code surface into Pi: shared OAuth login state with the official `kimi-code` CLI, Kimi Files API uploads, and Kimi-native tools such as `moonshot_search`, `moonshot_fetch`, and `kimi_datasource`. (Pi v0.82.0+ ships a built-in `kimi-coding` provider for the LLM layer; this extension covers everything around it.)
 
 ## Why this exists
 
-Pi is a small harness you adapt to your own workflow. Kimi Code is Moonshot's official coding agent. This package sits between them: Kimi Code as a Pi provider, plus the Kimi-specific details that the basic provider keeps simple.
-
-Kimi's API surface goes beyond the LLM itself. It includes file uploads, web search, page fetch, and a growing set of datasource APIs. This extension wires those capabilities into Pi so you can use them alongside the community's existing extensions — MCP servers, custom themes, skills, and any other Pi add-on — without leaving the harness.
+Use the built-in provider if you only want to chat with Kimi models. Install this extension when you also want the full Kimi Code surface inside Pi:
 
-- **Use your Kimi account.** Log in with `/login kimi-coding`, or reuse an existing `kimi-code` session.
+- **Share a session with the official `kimi-code` CLI.** Reuse an existing `kimi-code` login, or sync Pi's OAuth login back to `kimi-code` so both CLIs stay authenticated.
 - **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.
+- **Use Kimi-native tools.** `moonshot_search`, `moonshot_fetch`, and `kimi_datasource` are opt-in tools that call Moonshot's server-side services.
 - **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 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.
+- **Embed in your own build.** The `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-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's official catalog, including server-advertised model availability and context limits.
-- OpenAI-compatible mode by default, Anthropic-compatible mode on request.
-- 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: 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.
-- No build step; Pi loads the TypeScript extension directly.
+- **Credential reuse with `kimi-code`.** Reads `~/.kimi-code/credentials/kimi-code.json` and syncs refreshed OAuth tokens back to it.
+- **Kimi account login in Pi.** `/login kimi-coding` stores credentials in `~/.pi/agent/auth.json`; tokens refresh automatically.
+- **`KIMI_API_KEY` fallback.** For CI or key-based access.
+- **Kimi Files API uploads.** Uploads large inline images and references them as `ms://` instead of inline base64.
+- **Optional Kimi-native tools.** `moonshot_search`, `moonshot_fetch`, and `kimi_datasource` via `/kimi-settings`.
+- **Tool schema dedup.** Collapses repeated `$ref`/`$defs` structures to stay under Moonshot's 15 KB per-tool limit.
+- **Legacy provider registration.** Keeps existing model sessions loading; new users should use Pi's built-in provider.
+- **Programmatic `KimiCode()` factory.** Embed Kimi Code in a custom Pi build with config overrides.
+- **No build step.** Pi loads the TypeScript extension directly.
 
 ## Install
 
@@ -76,57 +65,32 @@ main(process.argv.slice(2), {
 
 `KimiCode()` with no arguments behaves identically to the file-based extension. Pass a `KimiCodeConfigPatch` to override defaults (protocol, upload threshold, tools, model parameters). See [docs/programmatic-usage.md](docs/programmatic-usage.md) for the full API.
 
-## Sign in
-
-Inside Pi, run:
-
-```text
-/login kimi-coding
-```
+## Authentication
 
-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:
+Pi's built-in `kimi-coding` provider already supports OAuth login via `/login`. This extension handles the credential layer around that login:
 
-```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
-```
-
-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:
+- **Syncs refreshed tokens back to `kimi-code`.** Pi stores credentials at `~/.pi/agent/auth.json`; this extension keeps the official CLI's credential file (`~/.kimi-code/credentials/kimi-code.json`) up to date so both stay authenticated.
+- **Reuses existing `kimi-code` sessions.** If you already use the official CLI, the extension reads its session directly. Set `KIMI_CODE_HOME` if its home directory lives somewhere else.
+- **Supports the legacy `~/.kimi` path.** Read-only. Set `KIMI_SHARE_DIR` to override it.
+- **`KIMI_API_KEY` fallback.** For CI or key-based access:
 
 ```bash
 KIMI_API_KEY=sk-... pi
 ```
 
-## Models
+## Models (legacy provider registration)
 
-The official catalog determines the models this provider publishes. The following IDs are the fallback set when catalog discovery is unavailable:
+> **New users:** Use Pi's built-in `kimi-coding` provider for model discovery, reasoning controls, and OAuth login. This extension keeps its own model registration only for backward compatibility with existing sessions.
 
-| Pi model ID                             | Default name             | Availability and context |
-| --------------------------------------- | ------------------------ | ------------------------ |
-| `kimi-coding/kimi-for-coding`           | Kimi K2.7 Code           | Official catalog         |
-| `kimi-coding/kimi-for-coding-highspeed` | Kimi K2.7 Code HighSpeed | Official catalog         |
-| `kimi-coding/k3`                        | Kimi K3                  | Official catalog         |
-
-Kimi's official catalog at `https://api.kimi.com/coding/v1/models` is authoritative for model availability and context windows. When discovery is unavailable, the extension uses the fallback models and defaults below.
+When this extension does register models, the official catalog determines what it publishes. The following IDs are the fallback set when catalog discovery is unavailable:
 
-Select a model inside Pi:
+| Pi model ID                             | Default name               | Source           |
+| --------------------------------------- | -------------------------- | ---------------- |
+| `kimi-coding/kimi-for-coding`           | Kimi for Coding            | Official catalog |
+| `kimi-coding/kimi-for-coding-highspeed` | Kimi for Coding High Speed | Official catalog |
+| `kimi-coding/k3`                        | Kimi K3                    | Official catalog |
 
-```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 reads the official catalog at startup, when credentials change, and through `/kimi-settings`. If your account is on a newer rollout (e.g., Kimi K2.7) or internal test, Pi can pick up the latest model IDs, names, and context sizes without waiting for a package release.
+Kimi's official catalog at `https://api.kimi.com/coding/v1/models` is authoritative for model availability and context windows. When discovery is unavailable, the extension uses the fallback models and defaults below.
 
 Fallback values:
 
@@ -141,7 +105,7 @@ Switching models or thinking effort invalidates Kimi's existing context cache. S
 
 ## Optional tools
 
-Kimi Coding has server-side capabilities that this extension can expose as opt-in tools. All tools are off by default. Enable them individually through `/kimi-settings` or JSON config.
+Kimi Code has server-side capabilities that this extension exposes as opt-in tools. All tools are off by default. Enable them individually through `/kimi-settings` or JSON config.
 
 Inside Pi, run:
 
@@ -149,7 +113,7 @@ Inside Pi, run:
 /kimi-settings
 ```
 
-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.
+That command shows your signed-in account (via Kimi's `/me` endpoint), 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.
 
@@ -200,6 +164,11 @@ Supported datasource names:
 | `arxiv`                | Academic paper search and metadata    |
 | `scholar`              | Academic literature search            |
 | `yuandian_law`         | Chinese legal database and case law   |
+| `wind`                 | A-share intraday series, funds, bonds |
+| `imf`                  | IMF FX, CPI, and GDP forecasts        |
+| `gildata`              | Natural-language stock/fund screening |
+| `sec_edgar`            | US SEC filings (10-K/10-Q, 13F, 8-K)  |
+| `sp_data`              | S&P fundamentals and transcripts      |
 
 ### Common notes
 
@@ -213,8 +182,8 @@ If you already use another search or fetch tool, pick one path for a session. Ov
 
 Most users do not need environment variables. Two are worth knowing:
 
-- `KIMI_API_KEY` — static API key for CI or pay-per-token use.
-- `KIMI_CODE_PROTOCOL` — `openai` by default; set to `anthropic` if your Pi setup needs Anthropic-compatible requests. Can also be set through `/kimi-settings` or JSON config.
+- `KIMI_API_KEY` — static API key for CI or key-based access.
+- `KIMI_CODE_PROTOCOL` — `openai` by default; set to `anthropic` for Anthropic-compatible requests.
 
 Tools, protocol, and upload threshold are all configurable through `/kimi-settings` or JSON config files.
 
@@ -224,30 +193,15 @@ The full env list, including base URL overrides, `kimi-code` path overrides, upl
 
 ### Kimi Code vs Pi
 
-`kimi-code` is Moonshot's official terminal agent. Pi is the harness you adapt to your own workflow: extensions, skills, prompts, themes, custom commands, status bars, and UI pieces. This package lets you keep Kimi Code as the model path while staying inside Pi.
+`kimi-code` is Moonshot's official terminal agent. Pi is the harness you adapt to your own workflow. Pi's built-in `kimi-coding` provider handles the LLM; this extension adds the rest of the Kimi Code surface to Pi.
 
 ### Cache behavior
 
-Kimi's cache is content-based. It fires automatically when your prompt prefix matches an earlier request. `prompt_cache_key`, Anthropic `cache_control` markers, and identifying headers like `X-Msh-Device-Id` are all ignored for cache decisions — cache is keyed purely by prompt content and is shared across machines, agent forks, and device-id rotations on the same Kimi account.
-
-See [docs/caching.md](docs/caching.md) for the measured behavior: TTL, cross-protocol cache reuse, 256-token prefix alignment, device-id sharing, and the cases that invalidate cache.
+Kimi's cache is content-based and keyed purely by prompt prefix. `prompt_cache_key`, Anthropic `cache_control` markers, and device-id headers are ignored. Cache benefits accrue within a session, not across cold starts. See [docs/caching.md](docs/caching.md) for measured behavior.
 
 ### Protocol modes
 
-Kimi's coding endpoint speaks both Anthropic and OpenAI dialects. This extension defaults to OpenAI-compatible mode.
-
-`KIMI_CODE_PROTOCOL` supports:
-
-- `openai` — default, uses `/coding/v1/chat/completions`
-- `anthropic` — uses `/coding/v1/messages`
-
-Use Anthropic mode if your Pi setup depends on Anthropic-style request or tool semantics.
-
-### Why OpenAI-compatible mode is the default
-
-The Anthropic-compatible protocol has an awkward tool-result shape: tool output is wrapped inside a `role: "user"` message. That is valid Anthropic format, but Kimi can sometimes read it like a real user message and continue from the wrong premise in multi-turn tool loops.
-
-The OpenAI-compatible protocol uses a dedicated `role: "tool"` message, so the boundary is clearer. That is why this extension now defaults to `openai`. The Anthropic path stays available for setups that need it. See [issue #5](https://github.com/Leechael/pi-provider-kimi-code/issues/5) for details.
+Kimi's coding endpoint speaks both Anthropic and OpenAI dialects. This extension defaults to OpenAI-compatible mode (`/coding/v1/chat/completions`) because it uses a dedicated `role: "tool"` message, which keeps tool results separate from user messages in multi-turn loops. Anthropic mode (`/coding/v1/messages`) is available if your setup depends on Anthropic-style semantics. See [issue #5](https://github.com/Leechael/pi-provider-kimi-code/issues/5) for details.
 
 ### Is this affiliated with Moonshot AI?
 
@@ -257,25 +211,19 @@ No. This is an independent extension. The login flow is derived from the public
 
 ### `pi` reports `fetch failed` even though `curl` works
 
-Pi runs on Node's `fetch` / undici stack, which handles `http_proxy` / `https_proxy` / `all_proxy` differently from `curl`. Verify those variables in the Pi process's environment. The bundled smoke-test script `scripts/test_e2e.sh` prints the effective proxy-related environment for easier debugging.
+Pi uses Node's `fetch` / undici stack, which handles `http_proxy` / `https_proxy` / `all_proxy` differently from `curl`. Check the proxy variables in the Pi process's environment. `scripts/test_e2e.sh` prints the effective proxy settings for debugging.
 
 ### `/login kimi-coding` prints a device code but the browser never opens
 
-The login flow always prints a verification URL. If your terminal or OS blocks auto-open, copy the URL and paste it into a browser manually.
+The login flow always prints a verification URL. Copy it into a browser manually if your terminal or OS blocks auto-open.
 
 ### "Access denied" or subscription errors after a successful login
 
-Your Moonshot account needs an active Kimi Code Plan for the provider to do anything useful. If the same account works in `kimi-code`, re-run `/login kimi-coding` to refresh credentials.
-
-### Tools do not show up
-
-Run `/kimi-settings` and check whether the tool is enabled in the home or project config. All tools also require `/login kimi-coding`; `KIMI_API_KEY` is not enough.
-
-If you changed the JSON config by hand, reload it through `/kimi-settings` or start a new Pi session.
+Your Moonshot account needs an active Kimi Code Plan. If the same account works in `kimi-code`, re-run `/login kimi-coding` to refresh credentials.
 
-### Tools return subscription or whitelist errors
+### Tools do not show up or return errors
 
-The tools call Moonshot's server-side services. Some accounts may not have access even with an active Kimi Code Plan. The error comes from the upstream service.
+Run `/kimi-settings` and check whether the tool is enabled in the home or project config. All tools require OAuth login; `KIMI_API_KEY` is not enough. Subscription or whitelist errors come from the upstream Moonshot service.
 
 ### Large images fail with a payload error
 
@@ -283,19 +231,11 @@ This extension uploads images over `KIMI_CODE_UPLOAD_THRESHOLD_BYTES` (default 1
 
 ### Prompt cache never seems to hit
 
-Kimi's cache is **content-based**: it fires automatically when your prompt prefix matches an earlier request, independent of any explicit cache key. If `cache_read_input_tokens` (Anthropic) or `cached_tokens` (OpenAI) stays at `0` across calls, something in the prompt is varying between turns. The usual suspects:
-
-- On the Anthropic-compat endpoint, the `system` prompt or the `tools` array changed (e.g. an extension changed the tool set mid-session). Either fully invalidates the cache — see [docs/caching.md](docs/caching.md), Finding 11. OpenAI-compat endpoint not yet measured for this scenario.
-- An `image_url` reference (`ms://<file_id>`) changed between turns. Same rule — see Finding 17.
-- You're comparing across two cold `pi` invocations, not within a single session. Cache benefits accrue **within** a session; Pi's system/tools assembly drifts between sessions. See Finding 18.
-- 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 a focused suite under `scripts/e2e/cache/`, starting with `scripts/e2e/cache/ttl.sh`. See [docs/caching.md](docs/caching.md) for full mechanics.
+Cache benefits accrue within a single session. If `cache_read_input_tokens` (Anthropic) or `cached_tokens` (OpenAI) stays at `0`, something in the prompt is varying between turns — a changed system prompt, tool set, `ms://` reference, or timestamp. See [docs/caching.md](docs/caching.md) for the full list of invalidation causes and measurement scripts.
 
 ### OpenAI-compatible tools complain about a `developer` role
 
-In OpenAI mode this extension maps the `developer` role to `system` (Kimi's Coding endpoint does not recognize `developer`). If something in your toolchain expects `developer` to round-trip, use Anthropic mode instead.
+In OpenAI mode this extension maps `developer` to `system` because Kimi's Coding endpoint does not recognize `developer`. Use Anthropic mode if your toolchain expects `developer` to round-trip.
 
 ## References
 
@@ -306,10 +246,6 @@ In OpenAI mode this extension maps the `developer` role to `system` (Kimi's Codi
 - Cache behavior: [docs/caching.md](docs/caching.md)
 - Architecture notes: [docs/architecture.md](docs/architecture.md)
 
-## Credits
-
-Based on the login implementation from Kimi Code by Moonshot AI. Pi was originally created by [@badlogic](https://github.com/badlogic).
-
 ## License
 
 MIT

package/index.ts

@@ -27,6 +27,9 @@ import {
 import { Input, SettingsList, type SettingItem, truncateToWidth } from "@earendil-works/pi-tui";
 import os from "node:os";
 
+// pi-ai <=0.79 has no "./compat"
+const piAiCompatModule = "@earendil-works/pi-ai/compat";
+
 import {
   type KimiCodeConfig,
   type KimiCodeConfigPatch,
@@ -38,7 +41,13 @@ import {
   saveProjectKimiCodeConfig,
   type KimiToolName,
 } from "./src/config.ts";
-import { PROVIDER_ID, PROVIDER_VERSION, getBaseUrl, getKimiApiType } from "./src/constants.ts";
+import {
+  KIMI_GLOBAL_FALLBACK_SOURCE_ID,
+  PROVIDER_ID,
+  PROVIDER_VERSION,
+  getBaseUrl,
+  getKimiApiType,
+} from "./src/constants.ts";
 import {
   type KimiOAuthCredentials,
   type KimiOAuthExtras,
@@ -53,7 +62,12 @@ import {
   hasKimiModelMetadata,
   resolveKimiModelConfig,
 } from "./src/models.ts";
-import { getKimiApiKey, loginKimiCode, refreshKimiCodeToken } from "./src/oauth.ts";
+import {
+  getKimiApiKey,
+  loginKimiCode,
+  refreshKimiAuthToken,
+  refreshKimiCodeToken,
+} from "./src/oauth.ts";
 import { isKimiProjectConfigApproved } from "./src/project-trust.ts";
 import {
   type KimiConfigScope,
@@ -63,12 +77,17 @@ import {
   parseByteSizeInput,
 } from "./src/settings-ui.ts";
 import { setStoreResolvedKimiConfig, streamSimpleKimi } from "./src/stream.ts";
-import { fetchKimiUsageSnapshot, getKimiUsageToken } from "./src/usage.ts";
+import {
+  fetchKimiUsageSnapshot,
+  fetchKimiUserInfoSnapshot,
+  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;
+  fallbackSourceId: string;
   modelExtras: KimiOAuthExtras;
   projectTrusted: boolean;
   overrides?: KimiCodeConfigPatch;
@@ -141,23 +160,39 @@ function applyEffectiveKimiRuntimeConfig(
   return config;
 }
 
-async function refreshModelExtras(state: KimiRuntimeState): Promise<boolean> {
-  const token = getKimiUsageToken();
+async function refreshModelExtras(
+  state: KimiRuntimeState,
+  token = getKimiUsageToken(),
+): Promise<boolean> {
   if (!token) return false;
-  const extras = await discoverKimiModelMetadata(token, state.config.protocol);
+  const extras = await discoverKimiModelMetadata(token, state.config.protocol, {
+    refreshAccessToken: refreshKimiAuthToken,
+  });
   if (Object.keys(extras).length === 0) return false;
   Object.assign(state.modelExtras, extras);
   return true;
 }
 
+// Discovery can lose a race with a concurrent OAuth refresh: the token it
+// started with may already be dead by the time the request goes out. Retry
+// once, but only when the stored token actually changed underneath us.
+async function discoverModelExtras(state: KimiRuntimeState): Promise<boolean> {
+  const token = getKimiUsageToken();
+  if (await refreshModelExtras(state, token)) return true;
+  const refreshedToken = getKimiUsageToken();
+  if (!refreshedToken || refreshedToken === token) return false;
+  return refreshModelExtras(state, refreshedToken);
+}
+
 async function openSettingsMenu(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
   state: KimiRuntimeState,
 ): Promise<void> {
   const modelDiscoveryToken = getKimiUsageToken();
-  const [usageSnapshot, initialModelsRefreshed] = await Promise.all([
+  const [usageSnapshot, userInfoSnapshot, initialModelsRefreshed] = await Promise.all([
     fetchKimiUsageSnapshot(),
+    fetchKimiUserInfoSnapshot(),
     refreshModelExtras(state),
   ]);
   let modelsRefreshed = initialModelsRefreshed;
@@ -165,8 +200,9 @@ async function openSettingsMenu(
   if (!modelsRefreshed && refreshedToken && refreshedToken !== modelDiscoveryToken) {
     modelsRefreshed = await refreshModelExtras(state);
   }
-  if (modelsRefreshed) registerKimiProvider(pi, state);
+  if (modelsRefreshed) await registerKimiProvider(pi, state);
   const usage = usageSnapshot.summary;
+  const account = userInfoSnapshot.summary;
 
   const projectTrusted = await isKimiProjectConfigApproved(ctx, ctx.cwd);
   const homeDraft = loadHomeKimiCodeConfig(os.homedir());
@@ -343,6 +379,9 @@ async function openSettingsMenu(
             width,
           ),
           "",
+          truncateToWidth(theme.fg("accent", theme.bold("Kimi account")), width),
+          truncateToWidth(`  ${account}`, width),
+          "",
           truncateToWidth(theme.fg("accent", theme.bold("Kimi usage")), width),
           ...usageLines,
           "",
@@ -402,7 +441,94 @@ function buildKimiCatalogModels(state: KimiRuntimeState) {
   );
 }
 
-function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
+// Node reports a missing subpath export (pi-ai <=0.79) and a missing package
+// with these codes. All mean "this pi-ai has no compat layer", which is an
+// expected configuration rather than a failure worth reporting: the fallback
+// simply does not exist there.
+//
+// MODULE_NOT_FOUND (the CJS code, without the ERR_ prefix) covers pi's jiti
+// extension loader on old pi versions: it aliases the bare "@earendil-works/pi-ai"
+// specifier straight to dist/index.js, so the "/compat" subpath degrades into
+// the bogus file path "dist/index.js/compat" and fails legacy CJS resolution
+// instead of exports-map resolution.
+const MODULE_UNAVAILABLE_CODES = new Set([
+  "ERR_MODULE_NOT_FOUND",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  "MODULE_NOT_FOUND",
+]);
+
+// Every api id this extension can hand out, not only the one for the currently
+// configured protocol: sessions persist the api id that was current when the
+// model was resolved, so a session created before a protocol switch still
+// carries the other id and would keep crashing. streamSimpleKimi routes on the
+// model's wireProtocol / the resolved runtime config and never on model.api, so
+// both ids dispatch identically.
+const KIMI_FALLBACK_APIS = [getKimiApiType("openai"), getKimiApiType("anthropic")];
+
+type PiAiApiRegistry = {
+  registerApiProvider: (
+    provider: {
+      api: string;
+      stream: typeof streamSimpleKimi;
+      streamSimple: typeof streamSimpleKimi;
+    },
+    sourceId: string,
+  ) => void;
+  unregisterApiProviders: (sourceId: string) => void;
+  getApiProvider: (api: string) => unknown;
+};
+
+async function loadPiAiApiRegistry(action: string): Promise<PiAiApiRegistry | null> {
+  try {
+    return (await import(piAiCompatModule)) as PiAiApiRegistry;
+  } catch (error: unknown) {
+    const code = (error as { code?: unknown } | undefined)?.code;
+    if (typeof code === "string" && MODULE_UNAVAILABLE_CODES.has(code)) return null;
+    console.error(
+      `[pi-provider-kimi-code] failed to ${action} the global api fallback:`,
+      error instanceof Error ? error.message : error,
+    );
+    return null;
+  }
+}
+
+let nextFallbackSourceId = 0;
+const liveFallbackSources = new Set<string>();
+
+function createKimiGlobalFallbackSourceId(): string {
+  nextFallbackSourceId += 1;
+  return `${KIMI_GLOBAL_FALLBACK_SOURCE_ID}:${nextFallbackSourceId}`;
+}
+
+async function registerKimiGlobalApiFallback(sourceId: string): Promise<void> {
+  if (!liveFallbackSources.has(sourceId)) return;
+  const registry = await loadPiAiApiRegistry("register");
+  if (!registry) return;
+  for (const api of KIMI_FALLBACK_APIS) {
+    // Never displace an entry someone else owns: this is a shared,
+    // process-wide table and the fallback only exists to fill a hole, not to
+    // win a conflict. pi-ai installs its own builtins under the same rule.
+    if (registry.getApiProvider(api)) continue;
+    registry.registerApiProvider(
+      { api, stream: streamSimpleKimi, streamSimple: streamSimpleKimi },
+      sourceId,
+    );
+  }
+}
+
+// The registry outlives each session. Remove only the entries owned by the
+// retiring runtime, then hand any holes to another live runtime.
+async function unregisterKimiGlobalApiFallback(sourceId: string): Promise<void> {
+  if (!liveFallbackSources.delete(sourceId)) return;
+  const registry = await loadPiAiApiRegistry("unregister");
+  if (!registry) return;
+  registry.unregisterApiProviders(sourceId);
+  const successor = liveFallbackSources.values().next().value;
+  if (successor) await registerKimiGlobalApiFallback(successor);
+}
+
+async function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): Promise<void> {
+  await registerKimiGlobalApiFallback(state.fallbackSourceId);
   pi.registerProvider(PROVIDER_ID, {
     baseUrl: getBaseUrl(state.config.protocol),
     apiKey: "$KIMI_API_KEY",
@@ -481,6 +607,50 @@ function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
   });
 }
 
+// What pi throws from any `pi` method once the extension runtime behind it has
+// been retired, which is what a /reload does. Same wording on every version
+// this extension supports (0.78.1 through 0.83.0); if it ever changes, the
+// worst case is that a reload race gets logged instead of ignored.
+const STALE_EXTENSION_RUNTIME_PREFIX = "This extension ctx is stale";
+
+let pendingModelDiscovery: Promise<void> = Promise.resolve();
+
+/**
+ * Resolves once the discovery started by the most recent extension load has
+ * settled. Nothing in the runtime waits for it; it exists so tests can observe
+ * the deferred registration without polling.
+ */
+export function kimiModelDiscoverySettled(): Promise<void> {
+  return pendingModelDiscovery;
+}
+
+// pi's extension loader awaits this factory before it builds the session, and
+// the TUI only draws its first frame after that returns, so a network round
+// trip here is a stall the user sees on every launch and every /reload. The
+// stored OAuth credential already carries the last known catalog (pi replays it
+// through oauth.modifyModels), so register what the config describes right away
+// and fold the fresh metadata in when it lands.
+function startModelDiscovery(pi: ExtensionAPI, state: KimiRuntimeState): void {
+  pendingModelDiscovery = discoverModelExtras(state)
+    .then((discovered) => {
+      if (!discovered) return;
+      reloadEffectiveKimiRuntimeConfig(state, state.cwd, state.projectTrusted);
+      return registerKimiProvider(pi, state);
+    })
+    .catch((error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error);
+      // A /reload retires this extension runtime while discovery may still be
+      // in flight, and registering against a retired runtime throws. The
+      // reloaded factory runs its own discovery, so there is nothing to redo.
+      if (message.startsWith(STALE_EXTENSION_RUNTIME_PREFIX)) return;
+      // Anything else used to surface as an extension load failure, back when
+      // this ran inside the factory. Deferring it must not make it invisible:
+      // the provider stays registered with the metadata it already had, and
+      // the user needs to know why it stopped refreshing.
+      console.error("[kimi-coding] deferred model discovery failed:", message);
+    });
+}
+
 export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
   return async (pi: ExtensionAPI) => {
     const cwd = process.cwd();
@@ -488,28 +658,22 @@ export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
       { cwd, home: os.homedir(), includeProject: false },
       overrides,
     );
-    const discoveryToken = getKimiUsageToken();
-    const initialDiscovery = discoveryToken
-      ? await discoverKimiModelMetadata(discoveryToken, config.protocol)
-      : {};
-    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,
+      fallbackSourceId: createKimiGlobalFallbackSourceId(),
+      modelExtras: {},
       projectTrusted: false,
       overrides,
     };
     reloadEffectiveKimiRuntimeConfig(state, cwd, false);
-    registerKimiProvider(pi, state);
+    liveFallbackSources.add(state.fallbackSourceId);
+    try {
+      await registerKimiProvider(pi, state);
+    } catch (error) {
+      liveFallbackSources.delete(state.fallbackSourceId);
+      throw error;
+    }
 
     registerConfiguredMoonshotTools(pi, state.config, { updateActiveTools: false });
 
@@ -519,7 +683,11 @@ export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
         updateActiveTools: true,
         projectTrusted,
       });
-      registerKimiProvider(pi, state);
+      await registerKimiProvider(pi, state);
+    });
+
+    pi.on("session_shutdown", async () => {
+      await unregisterKimiGlobalApiFallback(state.fallbackSourceId);
     });
 
     pi.registerCommand("kimi-settings", {
@@ -532,6 +700,8 @@ export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
         await openSettingsMenu(pi, ctx, state);
       },
     });
+
+    startModelDiscovery(pi, state);
   };
 }
 

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.8",
-  "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
+  "version": "0.6.10",
+  "description": "Kimi Code models (K3, K2.7, HighSpeed) in Pi: OAuth shared login with kimi-code CLI, file uploads, and Kimi-native tools",
   "keywords": [
     "ai-provider",
     "coding-agent",
+    "highspeed",
+    "k3",
     "kimi",
     "kimi-code",
+    "kimi-code-plan",
     "kimi-for-coding",
     "kimi-k2",
     "kimi-k2.5",
     "kimi-k2.6",
     "kimi-k2.7",
+    "kimi-k3",
     "llm",
     "llm-provider",
     "moonshot",
@@ -53,9 +57,9 @@
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.80.9",
-    "@earendil-works/pi-coding-agent": "^0.80.9",
-    "@earendil-works/pi-tui": "^0.80.9",
+    "@earendil-works/pi-ai": "^0.83.0",
+    "@earendil-works/pi-coding-agent": "^0.83.0",
+    "@earendil-works/pi-tui": "^0.83.0",
     "@j178/prek": "^0.4.4",
     "@types/node": "^24.0.0",
     "@types/proper-lockfile": "^4.1.4",