pi-provider-kimi-code 0.6.12 → 0.6.14

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## [0.6.14] - 2026-11-15
+
+### Changed
+
+- Upgraded `@earendil-works/pi-ai` / `pi-coding-agent` / `pi-tui` to `^1.5.0`. This resolves all npm audit findings (undici, minimatch, brace-expansion advisories) and picks up pi's streaming and rendering performance fixes.
+- Tool parameter schemas (`moonshot_search`, `moonshot_fetch`, `kimi_datasource`) now use `@earendil-works/pi-schema` builders instead of TypeBox, following pi 1.5.0's migration. The generated JSON Schema is unchanged.
+
+### Security
+
+- Device-code login now rejects verification URLs that are not `http:`/`https:`, mirroring pi 1.5.0's fix for built-in OAuth providers. A malicious or buggy authorization server can no longer hand pi a `file:` or custom-scheme URL to open.
+
+### Added
+
+- The `/kimi-coding` settings dialog now reports pi as blocked on user input (OSC 7501 program status) while it is open, so supporting terminals show the correct waiting state.
+- This changelog: pi 1.5.0 shows extension update notes on the next launch after an update.
+- The `/kimi-settings` dialog now exposes **Keep thinking** (`model.thinkingKeep`: `default` / `all` / `last` / `none`), controlling the `thinking.keep` value sent to the Kimi API — i.e. how much reasoning history the server retains across turns. The wire and config plumbing already existed; this makes it adjustable without editing JSON.
+- `kimi_datasource` now syncs its data-source catalog from the official plugin marketplace (`/coding/v1/plugins/marketplace`) with a lazy 24h disk cache (`~/.kimi-code/kimi-datasource-catalog.json`). The bundled snapshot moves from 12 to 35 sources (adds `china_*`, `who`/`fao`/`oecd`/`fred`, `chembl`/`pubchem`/`pdb`/`uniprot` and other science sources, `dongcai`/`cls`/`finance_research`), `data_source_name` is no longer a closed enum so server-side additions are never rejected by a stale client schema, and unknown names trigger one forced catalog refresh before being rejected with the current source list.
+- Model discovery now prefers the unified `/models` schema (`limit.context`, `reasoning.type`/`reasoning.effort.valid`/`default`, `modalities.input`) that the official kimi-code client switched to in #4209, keeping the legacy flat fields (`context_length`, `supports_reasoning`, `think_efforts`, ...) as fallback while the server still sends both.
+- Kimi's hard quota exhaustion (HTTP 429 with `exceeded_current_quota_error`) is now rewritten into actionable guidance — it is not a transient rate limit and retries will keep failing — pointing at `/kimi-settings` for usage, mirroring upstream kimi-code #4477/#4703. Plain transient 429s are untouched.

package/README.md

@@ -3,7 +3,9 @@
 [![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)
 
-> **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.)
+> **Kimi Code extension for Pi — use K3, K2.8 Code, and HighSpeed models with your Kimi Code Plan.**
+>
+> Why you need it: Pi v0.82.0+ ships a built-in `kimi-coding` provider for model discovery, reasoning controls, and OAuth login, but it does not provide this extension's Kimi Code integrations. Without this extension, Pi and the official `kimi-code` CLI log in separately (a login in one does not authenticate the other), large inline images blow up requests or fail because nothing uploads them through Kimi's Files API, Moonshot's server-side tools (`moonshot_search`, `moonshot_fetch`, `kimi_datasource`) are unavailable, Pi's tool schemas regularly exceed Moonshot's 15 KB per-tool limit and get rejected, and accounts on the wrong side of the mainland-cn / global split (kimi.com vs kimi.ai) fail with 401 because the built-in provider has no region switching. This extension closes those gaps — see [Why this exists](#why-this-exists) below for details.
 
 ## Why this exists
 
@@ -12,7 +14,8 @@ Use the built-in provider if you only want to chat with Kimi models. Install thi
 - **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.
 - **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.
+- **Meet Kimi's official schema requirements.** 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 adapts Pi's tool schemas to Kimi's requirements by automatically deduplicating them with `$ref`/`$defs` before sending, so subagents and other extensions don't break.
+- **Switch regions.** Kimi runs two managed sides (`mainland-cn` on kimi.com, `global` on kimi.ai). The extension carries the region selection through API endpoints, OAuth, and `/login`, so a kimi.ai account no longer dies with a 401 against the default `.com` endpoints.
 - **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
@@ -72,12 +75,25 @@ Pi's built-in `kimi-coding` provider already supports OAuth login via `/login`.
 - **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.
+- **Follows your region.** Managed endpoints follow the selected region (`mainland-cn` default, `global` for kimi.ai accounts) for API, OAuth, and `/login`. See [Region selection](#region-selection).
 - **`KIMI_API_KEY` fallback.** For CI or key-based access:
 
 ```bash
 KIMI_API_KEY=sk-... pi
 ```
 
+### Region selection
+
+Kimi runs two managed sides: `api.kimi.com` / `auth.kimi.com` (mainland China, default) and `api.kimi.ai` / `auth.kimi.ai` (global). If your account lives on the kimi.ai side, a global OAuth session or API key against the default `.com` endpoints fails with 401.
+
+Precedence, lowest to highest:
+
+1. Built-in default (`mainland-cn`)
+2. `KIMI_CODE_REGION` env var (`mainland-cn` or `global`)
+3. `region` in merged home/project `config.json` (`"mainland-cn"` / `"global"` / `null` = auto; project overrides home); the **Region** row in `/kimi-settings` edits this config
+
+`KIMI_CODE_BASE_URL` / `KIMI_CODE_OAUTH_HOST` overrides always win, and unknown values fall back to `mainland-cn`. `/login kimi-coding` follows the selected region end to end. See [docs/ENV.md](docs/ENV.md) for details.
+
 ## Models (legacy provider registration)
 
 > **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.
@@ -90,9 +106,9 @@ When this extension does register models, the official catalog determines what i
 | `kimi-coding/kimi-for-coding-highspeed` | Kimi for Coding High Speed | 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.
+Kimi's official catalog at `https://api.kimi.com/coding/v1/models` is authoritative for model availability and context windows. Since the K2.8 Preview rollout (2026-09-11), the `kimi-for-coding` ID is upgraded in place — same model ID, new engine, no config change needed. K2.8 advertises up to 1M tokens of context across all membership tiers; the catalog reports the exact window for your account.
 
-Fallback values:
+When discovery is unavailable, the extension uses the fallback models and defaults below (conservative pre-discovery values):
 
 - Context window: `256k` tokens
 - Max output: `32k` tokens
@@ -113,7 +129,7 @@ Inside Pi, run:
 /kimi-settings
 ```
 
-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.
+That command shows your signed-in account (via Kimi's `/me` endpoint), the current server-side model name (e.g. "K2.8 Code High Speed"), your Kimi quota and Extra Usage balance, the effective region, 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.
 
@@ -137,6 +153,7 @@ Project config overrides home config with a deep merge. Missing files or missing
 ```json
 {
   "protocol": "openai",
+  "region": "global",
   "uploads": { "thresholdBytes": 1048576 },
   "tools": {
     "moonshot_search": { "enabled": true, "default_collapsed": true },
@@ -184,6 +201,7 @@ Most users do not need environment variables. Two are worth knowing:
 
 - `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, or `responses` for the OpenAI Responses API.
+- `KIMI_CODE_REGION` — `mainland-cn` (default) or `global`; selects the managed API/OAuth endpoints for kimi.com vs kimi.ai accounts.
 
 Tools, protocol, and upload threshold are all configurable through `/kimi-settings` or JSON config files.
 
@@ -219,7 +237,7 @@ The login flow always prints a verification URL. Copy it into a browser manually
 
 ### "Access denied" or subscription errors after a successful login
 
-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.
+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. A 401 right after login can also mean a region mismatch — accounts registered on the kimi.ai side must run with `KIMI_CODE_REGION=global` (or the matching `region` config / `/kimi-settings` row).
 
 ### Tools do not show up or return errors
 
@@ -227,7 +245,7 @@ Run `/kimi-settings` and check whether the tool is enabled in the home or projec
 
 ### Large images fail with a payload error
 
-This extension uploads images over `KIMI_CODE_UPLOAD_THRESHOLD_BYTES` (default 1 MB) to Kimi's Files API and references them as `ms://`. Set `KIMI_CODE_DEBUG=1` to see upload decisions in the provider logs.
+This extension uploads images over `KIMI_CODE_UPLOAD_THRESHOLD_BYTES` (default 1 MB) to Kimi's Files API and references them as `ms://`. Independently of that, a per-request inline media budget (~20 MB of base64 on the wire) drops oversized inline images and videos from the payload and leaves a media-kind-specific placeholder, such as `[image omitted: dropped to fit the request media budget]` or `[video omitted: dropped to fit the request media budget]`, so the model knows content was removed. Set `KIMI_CODE_DEBUG=1` to see upload and budget decisions in the provider logs.
 
 ### Prompt cache never seems to hit
 

package/index.ts

@@ -46,8 +46,11 @@ import {
   KIMI_WIRE_PROTOCOLS,
   PROVIDER_ID,
   PROVIDER_VERSION,
+  type KimiRegion,
+  applyKimiRegionEnvBridge,
   getBaseUrl,
   getKimiApiType,
+  setKimiRegionOverride,
 } from "./src/constants.ts";
 import {
   type KimiOAuthCredentials,
@@ -74,6 +77,7 @@ import {
   type KimiConfigScope,
   buildSettingsTheme,
   formatByteSize,
+  formatRegionValue,
   formatScopeDescription,
   parseByteSizeInput,
 } from "./src/settings-ui.ts";
@@ -139,6 +143,12 @@ function reloadEffectiveKimiRuntimeConfig(
   state.cwd = cwd;
   state.config = config;
   state.projectTrusted = projectTrusted;
+  // Push the effective region (project/home JSON wins over the env capture;
+  // env KIMI_CODE_REGION already sits in the merged config via the env layer)
+  // and re-bridge pi core's OAuth host so /login follows settings changes
+  // without a restart.
+  setKimiRegionOverride(config.region);
+  applyKimiRegionEnvBridge();
   setStoreResolvedKimiConfig({
     model: resolveKimiModelConfig(
       config.model,
@@ -214,190 +224,225 @@ async function openSettingsMenu(
   let scope: KimiConfigScope = projectTrusted ? "project" : "home";
   let dirty = false;
 
-  await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
-    const settingsTheme = buildSettingsTheme(theme);
+  await ctx.ui.custom<void>(
+    (tui, theme, _keybindings, done) => {
+      const settingsTheme = buildSettingsTheme(theme);
 
-    let list: SettingsList;
+      let list: SettingsList;
 
-    const toolLabel = (toolName: KimiToolName) => {
-      if (toolName === "moonshot_search") return "Search tool";
-      if (toolName === "moonshot_fetch") return "Fetch tool";
-      return "Real-world data API";
-    };
-
-    const formatToolMenuValue = (toolName: KimiToolName) => {
-      const tool = drafts[scope].tools[toolName];
-      if (!tool.enabled) return "disabled";
-      return tool.default_collapsed ? "enabled without preview" : "enabled with preview";
-    };
+      const toolLabel = (toolName: KimiToolName) => {
+        if (toolName === "moonshot_search") return "Search tool";
+        if (toolName === "moonshot_fetch") return "Fetch tool";
+        return "Real-world data API";
+      };
 
-    const refreshDisplays = () => {
-      scopeItem.description = formatScopeDescription(scope, ctx.cwd);
-      for (const toolName of KIMI_TOOL_NAMES) {
-        list.updateValue(toolName, formatToolMenuValue(toolName));
-      }
-      list.updateValue("protocol", drafts[scope].protocol);
-      list.updateValue("uploadThreshold", formatByteSize(drafts[scope].uploads.thresholdBytes));
-    };
+      const formatToolMenuValue = (toolName: KimiToolName) => {
+        const tool = drafts[scope].tools[toolName];
+        if (!tool.enabled) return "disabled";
+        return tool.default_collapsed ? "enabled without preview" : "enabled with preview";
+      };
 
-    const save = () => {
-      if (scope === "project" && !projectTrusted) {
-        ctx.ui.notify("Project config cannot be saved until the project is trusted.", "warning");
-        return;
-      }
-      try {
-        saveScopeKimiCodeConfig(scope, ctx.cwd, drafts[scope]);
-        applyEffectiveKimiRuntimeConfig(pi, state, ctx.cwd, {
-          updateActiveTools: true,
-          projectTrusted: scope === "project" ? true : projectTrusted,
-        });
-        dirty = true;
-      } catch (error: unknown) {
-        ctx.ui.notify((error as Error).message, "error");
-      }
-    };
-
-    const onChange = (id: string, newValue: string) => {
-      if (id === "scope") {
-        scope = newValue as KimiConfigScope;
-        refreshDisplays();
-        return;
-      }
-      if (id === "protocol") {
-        drafts[scope].protocol = newValue as KimiCodeConfig["protocol"];
-        list.updateValue(id, newValue);
-        save();
-        return;
-      }
-      if (id === "uploadThreshold") {
-        const bytes = parseByteSizeInput(newValue);
-        if (bytes === undefined || bytes <= 0) {
-          ctx.ui.notify("Upload threshold must be a positive size, for example 2 MiB", "error");
+      const refreshDisplays = () => {
+        scopeItem.description = formatScopeDescription(scope, ctx.cwd);
+        for (const toolName of KIMI_TOOL_NAMES) {
+          list.updateValue(toolName, formatToolMenuValue(toolName));
+        }
+        list.updateValue("protocol", drafts[scope].protocol);
+        list.updateValue("region", formatRegionValue(drafts[scope].region));
+        list.updateValue("uploadThreshold", formatByteSize(drafts[scope].uploads.thresholdBytes));
+        list.updateValue("thinkingKeep", drafts[scope].model.thinkingKeep ?? "default");
+      };
+
+      const save = () => {
+        if (scope === "project" && !projectTrusted) {
+          ctx.ui.notify("Project config cannot be saved until the project is trusted.", "warning");
           return;
         }
-        drafts[scope].uploads.thresholdBytes = bytes;
-        list.updateValue(id, formatByteSize(bytes));
-        save();
-        return;
-      }
-      const toolMatch = /^(?<tool>.+):(?<field>enabled|collapsed)$/.exec(id);
-      if (toolMatch?.groups) {
-        const toolName = toolMatch.groups.tool as KimiToolName;
-        const field = toolMatch.groups.field as "enabled" | "collapsed";
-        if (field === "enabled") {
-          drafts[scope].tools[toolName].enabled = newValue === "true";
-        } else {
-          drafts[scope].tools[toolName].default_collapsed = newValue !== "true";
+        try {
+          saveScopeKimiCodeConfig(scope, ctx.cwd, drafts[scope]);
+          applyEffectiveKimiRuntimeConfig(pi, state, ctx.cwd, {
+            updateActiveTools: true,
+            projectTrusted: scope === "project" ? true : projectTrusted,
+          });
+          dirty = true;
+        } catch (error: unknown) {
+          ctx.ui.notify((error as Error).message, "error");
         }
-        list.updateValue(toolName, formatToolMenuValue(toolName));
-        save();
-      }
-    };
-
-    const scopeItem: SettingItem = {
-      id: "scope",
-      label: "Config scope",
-      description: projectTrusted
-        ? formatScopeDescription(scope, ctx.cwd)
-        : "Project config disabled until the project is trusted; editing home config only",
-      currentValue: scope,
-      values: projectTrusted ? ["project", "home"] : ["home"],
-    };
+      };
 
-    const items: SettingItem[] = [scopeItem];
-    for (const toolName of KIMI_TOOL_NAMES) {
-      items.push({
-        id: toolName,
-        label: toolLabel(toolName),
-        description: `Configure ${toolName} registration and preview defaults`,
-        currentValue: formatToolMenuValue(toolName),
-        submenu: (_current, submenuDone) =>
-          new SettingsList(
-            [
-              {
-                id: `${toolName}:enabled`,
-                label: "Enabled",
-                description: `Register ${toolName} at session start`,
-                currentValue: String(drafts[scope].tools[toolName].enabled),
-                values: ["true", "false"],
-              },
-              {
-                id: `${toolName}:collapsed`,
-                label: "Show preview",
-                description: `Show ${toolName} result previews by default`,
-                currentValue: String(!drafts[scope].tools[toolName].default_collapsed),
-                values: ["true", "false"],
-              },
-            ],
-            2,
-            settingsTheme,
-            onChange,
-            () => submenuDone(),
-          ),
-      });
-    }
-    items.push({
-      id: "protocol",
-      label: "Protocol",
-      description: "API protocol for Kimi requests",
-      currentValue: drafts[scope].protocol,
-      values: ["openai", "anthropic", "responses"],
-    });
-    items.push({
-      id: "uploadThreshold",
-      label: "Upload threshold",
-      description: "Max size for inline file uploads",
-      currentValue: formatByteSize(drafts[scope].uploads.thresholdBytes),
-      submenu: (_current, submenuDone) => {
-        const input = new Input();
-        input.setValue(formatByteSize(drafts[scope].uploads.thresholdBytes));
-        input.onSubmit = (value) => {
-          const bytes = parseByteSizeInput(value);
+      const onChange = (id: string, newValue: string) => {
+        if (id === "scope") {
+          scope = newValue as KimiConfigScope;
+          refreshDisplays();
+          return;
+        }
+        if (id === "protocol") {
+          drafts[scope].protocol = newValue as KimiCodeConfig["protocol"];
+          list.updateValue(id, newValue);
+          save();
+          return;
+        }
+        if (id === "region") {
+          drafts[scope].region = newValue === "auto" ? null : (newValue as KimiRegion);
+          list.updateValue(id, newValue);
+          save();
+          return;
+        }
+        if (id === "uploadThreshold") {
+          const bytes = parseByteSizeInput(newValue);
           if (bytes === undefined || bytes <= 0) {
             ctx.ui.notify("Upload threshold must be a positive size, for example 2 MiB", "error");
-            submenuDone();
             return;
           }
-          submenuDone(formatByteSize(bytes));
-        };
-        input.onEscape = () => submenuDone();
-        return input;
-      },
-    });
+          drafts[scope].uploads.thresholdBytes = bytes;
+          list.updateValue(id, formatByteSize(bytes));
+          save();
+          return;
+        }
+        if (id === "thinkingKeep") {
+          drafts[scope].model.thinkingKeep =
+            newValue === "default" ? null : (newValue as KimiCodeConfig["model"]["thinkingKeep"]);
+          list.updateValue(id, newValue);
+          save();
+          return;
+        }
+        const toolMatch = /^(?<tool>.+):(?<field>enabled|collapsed)$/.exec(id);
+        if (toolMatch?.groups) {
+          const toolName = toolMatch.groups.tool as KimiToolName;
+          const field = toolMatch.groups.field as "enabled" | "collapsed";
+          if (field === "enabled") {
+            drafts[scope].tools[toolName].enabled = newValue === "true";
+          } else {
+            drafts[scope].tools[toolName].default_collapsed = newValue !== "true";
+          }
+          list.updateValue(toolName, formatToolMenuValue(toolName));
+          save();
+        }
+      };
+
+      const scopeItem: SettingItem = {
+        id: "scope",
+        label: "Config scope",
+        description: projectTrusted
+          ? formatScopeDescription(scope, ctx.cwd)
+          : "Project config disabled until the project is trusted; editing home config only",
+        currentValue: scope,
+        values: projectTrusted ? ["project", "home"] : ["home"],
+      };
+
+      const items: SettingItem[] = [scopeItem];
+      for (const toolName of KIMI_TOOL_NAMES) {
+        items.push({
+          id: toolName,
+          label: toolLabel(toolName),
+          description: `Configure ${toolName} registration and preview defaults`,
+          currentValue: formatToolMenuValue(toolName),
+          submenu: (_current, submenuDone) =>
+            new SettingsList(
+              [
+                {
+                  id: `${toolName}:enabled`,
+                  label: "Enabled",
+                  description: `Register ${toolName} at session start`,
+                  currentValue: String(drafts[scope].tools[toolName].enabled),
+                  values: ["true", "false"],
+                },
+                {
+                  id: `${toolName}:collapsed`,
+                  label: "Show preview",
+                  description: `Show ${toolName} result previews by default`,
+                  currentValue: String(!drafts[scope].tools[toolName].default_collapsed),
+                  values: ["true", "false"],
+                },
+              ],
+              2,
+              settingsTheme,
+              onChange,
+              () => submenuDone(),
+            ),
+        });
+      }
+      items.push({
+        id: "protocol",
+        label: "Protocol",
+        description: "API protocol for Kimi requests",
+        currentValue: drafts[scope].protocol,
+        values: ["openai", "anthropic", "responses"],
+      });
+      items.push({
+        id: "region",
+        label: "Region",
+        description: "Managed deployment region (auto follows KIMI_CODE_REGION / default)",
+        currentValue: formatRegionValue(drafts[scope].region),
+        values: ["auto", "mainland-cn", "global"],
+      });
+      items.push({
+        id: "thinkingKeep",
+        label: "Keep thinking",
+        description:
+          "thinking.keep sent to the Kimi API: how much reasoning history the server should retain across turns",
+        currentValue: drafts[scope].model.thinkingKeep ?? "default",
+        values: ["default", "all", "last", "none"],
+      });
+      items.push({
+        id: "uploadThreshold",
+        label: "Upload threshold",
+        description: "Max size for inline file uploads",
+        currentValue: formatByteSize(drafts[scope].uploads.thresholdBytes),
+        submenu: (_current, submenuDone) => {
+          const input = new Input();
+          input.setValue(formatByteSize(drafts[scope].uploads.thresholdBytes));
+          input.onSubmit = (value) => {
+            const bytes = parseByteSizeInput(value);
+            if (bytes === undefined || bytes <= 0) {
+              ctx.ui.notify("Upload threshold must be a positive size, for example 2 MiB", "error");
+              submenuDone();
+              return;
+            }
+            submenuDone(formatByteSize(bytes));
+          };
+          input.onEscape = () => submenuDone();
+          return input;
+        },
+      });
 
-    list = new SettingsList(items, items.length, settingsTheme, onChange, () => done(), {
-      enableSearch: true,
-    });
+      list = new SettingsList(items, items.length, settingsTheme, onChange, () => done(), {
+        enableSearch: true,
+      });
 
-    return {
-      items,
-      onChange,
-      render(width: number) {
-        const usageLines = usage.split("\n").map((line) => truncateToWidth(`  ${line}`, width));
-        return [
-          truncateToWidth(
-            theme.fg("accent", theme.bold(`Kimi settings (provider v${PROVIDER_VERSION})`)),
-            width,
-          ),
-          "",
-          truncateToWidth(theme.fg("accent", theme.bold("Kimi account")), width),
-          truncateToWidth(`  ${account}`, width),
-          "",
-          truncateToWidth(theme.fg("accent", theme.bold("Kimi usage")), width),
-          ...usageLines,
-          "",
-          ...list.render(width),
-        ];
-      },
-      handleInput(data: string) {
-        list.handleInput?.(data);
-        tui.requestRender();
-      },
-      invalidate() {
-        list.invalidate();
-      },
-    };
-  });
+      return {
+        items,
+        onChange,
+        render(width: number) {
+          const usageLines = usage.split("\n").map((line) => truncateToWidth(`  ${line}`, width));
+          return [
+            truncateToWidth(
+              theme.fg("accent", theme.bold(`Kimi settings (provider v${PROVIDER_VERSION})`)),
+              width,
+            ),
+            "",
+            truncateToWidth(theme.fg("accent", theme.bold("Kimi account")), width),
+            truncateToWidth(`  ${account}`, width),
+            "",
+            truncateToWidth(theme.fg("accent", theme.bold("Kimi usage")), width),
+            ...usageLines,
+            "",
+            ...list.render(width),
+          ];
+        },
+        handleInput(data: string) {
+          list.handleInput?.(data);
+          tui.requestRender();
+        },
+        invalidate() {
+          list.invalidate();
+        },
+      };
+    },
+    {
+      blocked: { kind: "question", message: "Kimi settings" },
+    },
+  );
 
   if (dirty) await ctx.reload();
 }
@@ -654,6 +699,9 @@ function startModelDiscovery(pi: ExtensionAPI, state: KimiRuntimeState): void {
 
 export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
   return async (pi: ExtensionAPI) => {
+    // Region handling (setKimiRegionOverride + the OAuth host bridge) happens
+    // in reloadEffectiveKimiRuntimeConfig, which runs just below and on every
+    // /kimi-settings save.
     const cwd = process.cwd();
     const config = loadKimiCodeConfig(
       { cwd, home: os.homedir(), includeProject: false },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.12",
-  "description": "Kimi Code models (K3, K2.7, HighSpeed) in Pi: OAuth shared login with kimi-code CLI, file uploads, and Kimi-native tools",
+  "version": "0.6.14",
+  "description": "Kimi Code models (K3, K2.8, HighSpeed) in Pi: OAuth shared login with kimi-code CLI, file uploads, and Kimi-native tools",
   "keywords": [
     "ai-provider",
     "coding-agent",
@@ -15,6 +15,7 @@
     "kimi-k2.5",
     "kimi-k2.6",
     "kimi-k2.7",
+    "kimi-k2.8",
     "kimi-k3",
     "llm",
     "llm-provider",
@@ -40,7 +41,8 @@
     "index.ts",
     "src",
     "package.json",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "scripts": {
@@ -54,23 +56,24 @@
     "pre-commit": "prek run"
   },
   "dependencies": {
+    "@earendil-works/pi-schema": "^1.5.0",
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.85.1",
-    "@earendil-works/pi-coding-agent": "^0.85.1",
-    "@earendil-works/pi-tui": "^0.85.1",
-    "@j178/prek": "^0.5.2",
-    "@types/node": "^24.0.0",
+    "@earendil-works/pi-ai": "^1.5.0",
+    "@earendil-works/pi-coding-agent": "^1.5.0",
+    "@earendil-works/pi-tui": "^1.5.0",
+    "@j178/prek": "^0.5.10",
+    "@types/node": "^24.19.2",
     "@types/proper-lockfile": "^4.1.4",
-    "oxfmt": "^0.67.0",
-    "oxlint": "^1.82.0",
+    "oxfmt": "^0.77.0",
+    "oxlint": "^1.92.0",
     "typescript": "^5.9.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-ai": ">=1.5.0",
+    "@earendil-works/pi-coding-agent": ">=1.5.0",
+    "@earendil-works/pi-tui": ">=1.5.0"
   },
   "pi": {
     "extensions": [