pi-provider-kimi-code 0.6.12 → 0.6.13

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,
@@ -237,6 +247,7 @@ async function openSettingsMenu(
         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));
     };
 
@@ -269,6 +280,12 @@ async function openSettingsMenu(
         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) {
@@ -343,6 +360,13 @@ async function openSettingsMenu(
       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: "uploadThreshold",
       label: "Upload threshold",
@@ -654,6 +678,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.13",
+  "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",
@@ -57,9 +58,9 @@
     "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",
+    "@earendil-works/pi-ai": "^0.99.2",
+    "@earendil-works/pi-coding-agent": "^0.99.2",
+    "@earendil-works/pi-tui": "^0.99.2",
     "@j178/prek": "^0.5.2",
     "@types/node": "^24.0.0",
     "@types/proper-lockfile": "^4.1.4",

package/src/config.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
-import { PROVIDER_ID, type KimiWireProtocol } from "./constants.ts";
+import { PROVIDER_ID, type KimiRegion, type KimiWireProtocol } from "./constants.ts";
 
 export const KIMI_TOOL_NAMES = ["moonshot_search", "moonshot_fetch", "kimi_datasource"] as const;
 
@@ -47,6 +47,13 @@ export interface KimiCodeConfig {
   tools: Record<KimiToolName, { enabled: boolean; default_collapsed: boolean }>;
   uploads: { thresholdBytes: number };
   protocol: KimiWireProtocol;
+  /**
+   * Managed region for the default endpoints. `null` means "not specified
+   * here" — the module-load `KIMI_CODE_REGION` env capture (or the
+   * mainland-cn default) then decides. An explicit value from project/home
+   * config wins over the env capture once pushed via setKimiRegionOverride.
+   */
+  region: KimiRegion | null;
 }
 
 export type KimiCodeConfigPatch = Partial<{
@@ -62,6 +69,7 @@ export type KimiCodeConfigPatch = Partial<{
   tools: Partial<Record<KimiToolName, Partial<{ enabled: unknown; default_collapsed: unknown }>>>;
   uploads: Partial<{ thresholdBytes: unknown }>;
   protocol: unknown;
+  region: unknown;
 }>;
 
 export interface KimiCodeConfigSources {
@@ -81,6 +89,7 @@ export interface KimiCodeConfigSources {
   tools: Record<KimiToolName, { enabled: KimiConfigSource; default_collapsed: KimiConfigSource }>;
   uploads: { thresholdBytes: KimiConfigSource };
   protocol: KimiConfigSource;
+  region: KimiConfigSource;
 }
 
 export interface LoadKimiCodeConfigOptions {
@@ -132,6 +141,7 @@ export const DEFAULT_KIMI_CODE_CONFIG: KimiCodeConfig = {
   tools: makeDefaultTools(),
   uploads: { thresholdBytes: 1048576 },
   protocol: "openai",
+  region: null,
 };
 
 let runtimeOverride: KimiCodeConfigPatch = {};
@@ -257,6 +267,12 @@ function envConfigPatch(env: NodeJS.ProcessEnv): KimiCodeConfigPatch {
   const protocol = env.KIMI_CODE_PROTOCOL?.trim();
   if (protocol) patch.protocol = protocol;
 
+  // KIMI_CODE_REGION intentionally does NOT enter the merged config: the env
+  // acts as a fallback below the config.json layers (documented precedence:
+  // explicit config > env > built-in default), and an invalid value must not
+  // crash startup via strict validation — currentKimiRegion() falls back to
+  // the module-load capture instead.
+
   const capabilities = env.KIMI_MODEL_CAPABILITIES;
   if (capabilities) {
     const caps = new Set(
@@ -323,6 +339,20 @@ function requireProtocol(
   );
 }
 
+function requireRegionOrNull(
+  raw: unknown,
+  configPath: string,
+  pointer: string,
+): KimiCodeConfig["region"] {
+  if (raw === null) return null;
+  if (raw === "mainland-cn" || raw === "global") return raw;
+  return fail(
+    configPath,
+    pointer,
+    `expected "mainland-cn" | "global" | null, got ${JSON.stringify(raw)}`,
+  );
+}
+
 function requireInputArray(raw: unknown, configPath: string, pointer: string): KimiInputModality[] {
   const valid = new Set(["text", "image", "video"]);
   if (!Array.isArray(raw)) return fail(configPath, pointer, `expected an array, got ${typeof raw}`);
@@ -438,6 +468,7 @@ export function validateKimiCodeConfig(
       ),
     },
     protocol: requireProtocol(config.protocol, configPath, "/protocol"),
+    region: requireRegionOrNull(config.region, configPath, "/region"),
   };
 }
 
@@ -487,6 +518,7 @@ function buildSources(
     tools,
     uploads: { thresholdBytes: sourceForPath(layers, ["uploads", "thresholdBytes"]) },
     protocol: sourceForPath(layers, ["protocol"]),
+    region: sourceForPath(layers, ["region"]),
   };
 }
 

package/src/constants.ts

@@ -7,7 +7,82 @@ import os from "node:os";
 import { join } from "node:path";
 
 export const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
-export const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
+
+// Region profiles mirror upstream kimi-code's packages/oauth region.ts: a
+// region is a bundle of the managed API base origin and the OAuth host. The
+// region only picks the DEFAULT endpoints — explicit env overrides
+// (KIMI_CODE_BASE_URL / KIMI_CODE_OAUTH_HOST) always win. Global users with
+// kimi.ai credentials otherwise hit 401s against the hardcoded .com defaults
+// (issue #77).
+export type KimiRegion = "mainland-cn" | "global";
+
+export const KIMI_REGION_PROFILES: Record<KimiRegion, { apiBase: string; oauthHost: string }> = {
+  "mainland-cn": { apiBase: "https://api.kimi.com", oauthHost: "https://auth.kimi.com" },
+  global: { apiBase: "https://api.kimi.ai", oauthHost: "https://auth.kimi.ai" },
+};
+
+export function parseKimiRegion(value: string | undefined): KimiRegion {
+  if (value === "global" || value === "mainland-cn") return value;
+  return "mainland-cn";
+}
+
+export const ENV_KIMI_CODE_REGION: KimiRegion = parseKimiRegion(process.env.KIMI_CODE_REGION);
+
+// Effective region pushed from the plugin config (project/home JSON via
+// /kimi-settings), taking precedence over the module-load env capture so a
+// settings change applies without a restart. `null` means "config did not
+// specify" and falls back to ENV_KIMI_CODE_REGION.
+let resolvedRegionOverride: KimiRegion | null = null;
+
+export function setKimiRegionOverride(region: KimiRegion | null): void {
+  resolvedRegionOverride = region;
+}
+
+export function currentKimiRegion(): KimiRegion {
+  return resolvedRegionOverride ?? ENV_KIMI_CODE_REGION;
+}
+
+// Tracks a KIMI_CODE_OAUTH_HOST value injected by the bridge so a re-apply
+// (e.g. region switched back to mainland in /kimi-settings) can retract it
+// without clobbering a value the user configured in the meantime.
+let regionBridgeOwnedValue: string | undefined;
+
+// Bridge the selected region into pi core's built-in Kimi OAuth: pi-ai reads
+// KIMI_CODE_OAUTH_HOST at call time, so filling it makes /login follow the
+// configured region even when the login runs through pi's own kimi-coding
+// auth path instead of this extension's. Only fills the variable when the
+// region is non-default and the user has not configured an explicit override.
+export function applyKimiRegionEnvBridge(
+  env: NodeJS.ProcessEnv = process.env,
+  region: KimiRegion = currentKimiRegion(),
+): boolean {
+  if (regionBridgeOwnedValue !== undefined && env.KIMI_CODE_OAUTH_HOST === regionBridgeOwnedValue) {
+    delete env.KIMI_CODE_OAUTH_HOST;
+  }
+  regionBridgeOwnedValue = undefined;
+  // pi core's OAuth reads only KIMI_CODE_OAUTH_HOST; mirror the documented
+  // KIMI_OAUTH_HOST alias into it so the alias keeps working on the built-in
+  // login path. The alias stays the source of truth.
+  if (!env.KIMI_CODE_OAUTH_HOST && env.KIMI_OAUTH_HOST?.trim()) {
+    env.KIMI_CODE_OAUTH_HOST = env.KIMI_OAUTH_HOST.trim();
+    regionBridgeOwnedValue = env.KIMI_CODE_OAUTH_HOST;
+  }
+  if (region === "mainland-cn") return false;
+  if (env.KIMI_CODE_OAUTH_HOST || env.KIMI_OAUTH_HOST) return false;
+  env.KIMI_CODE_OAUTH_HOST = KIMI_REGION_PROFILES[region].oauthHost;
+  regionBridgeOwnedValue = env.KIMI_CODE_OAUTH_HOST;
+  return true;
+}
+
+/** Normalize any managed base URL to its `/v1` form. Single implementation
+ * shared by the tool endpoints (src/tools/common.ts), the usage/account URLs
+ * (src/usage.ts), and the credential probe (src/oauth.ts). */
+export function normalizeKimiBaseV1(baseUrl: string): string {
+  const base = baseUrl.replace(/\/+$/, "");
+  return base.endsWith("/v1") ? base : `${base}/v1`;
+}
+
+export const DEFAULT_OAUTH_HOST = KIMI_REGION_PROFILES[ENV_KIMI_CODE_REGION].oauthHost;
 
 export const KIMI_WIRE_PROTOCOLS = ["openai", "anthropic", "responses"] as const;
 export type KimiWireProtocol = (typeof KIMI_WIRE_PROTOCOLS)[number];
@@ -48,15 +123,17 @@ export function getKimiApiType(protocol: KimiWireProtocol): KimiApiType {
 // built-in anthropic-messages / openai-completions / openai-responses handlers.
 export const KIMI_API_TYPE = getKimiApiType(ENV_KIMI_CODE_PROTOCOL);
 
-export function getDefaultBaseUrl(protocol: KimiWireProtocol): string {
-  return protocol === "anthropic"
-    ? "https://api.kimi.com/coding"
-    : "https://api.kimi.com/coding/v1";
+export function getDefaultBaseUrl(
+  protocol: KimiWireProtocol,
+  region: KimiRegion = currentKimiRegion(),
+): string {
+  const apiBase = KIMI_REGION_PROFILES[region].apiBase;
+  return protocol === "anthropic" ? `${apiBase}/coding` : `${apiBase}/coding/v1`;
 }
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const PROVIDER_VERSION = "0.6.12";
+export const PROVIDER_VERSION = "0.6.13";
 
 export const KIMI_CODE_USER_AGENT = `pi-provider-kimi-code/${PROVIDER_VERSION}`;
 export const KIMI_PLATFORM = "pi";
@@ -79,9 +156,9 @@ export const PROVIDER_ID = "kimi-coding";
 export const KIMI_GLOBAL_FALLBACK_SOURCE_ID = "pi-provider-kimi-code-global-fallback";
 
 export function getOAuthHost(): string {
-  const value =
-    process.env.KIMI_CODE_OAUTH_HOST || process.env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST;
-  return value.trim() || DEFAULT_OAUTH_HOST;
+  const value = process.env.KIMI_CODE_OAUTH_HOST || process.env.KIMI_OAUTH_HOST;
+  if (value?.trim()) return value.trim();
+  return KIMI_REGION_PROFILES[currentKimiRegion()].oauthHost;
 }
 
 export function getBaseUrl(protocol: KimiWireProtocol = ENV_KIMI_CODE_PROTOCOL): string {

package/src/models.ts

@@ -99,6 +99,15 @@ function resolveModelCost(
 // per-request cap still wins (options.maxTokens ?? model.maxTokens). Reconcile
 // wherever contextWindow is authored so the two stay in lockstep.
 //
+// Wire note (upstream kimi-code #4091): the OpenAI wires now omit the
+// completion cap entirely unless one is explicitly configured —
+// applyKimiPayloadMutations drops the pi-ai-seeded cap when the model cap is
+// window-tracked, keeping it only for Anthropic /messages (which requires
+// max_tokens, where the window-clamped value matches upstream's
+// kimiUnsetCompletionTokens). The window-tracked maxTokens therefore feeds
+// pi-ai internals (thinking-budget math) and the Anthropic wire, not the
+// OpenAI payloads.
+//
 // "Explicitly configured" means any value other than the built-in default:
 // ensureKimiCodeConfig materializes the full default config (including
 // maxTokens) into the home config file, so config-source tracking cannot
@@ -246,10 +255,15 @@ function getModelsUrl(protocol?: KimiWireProtocol): string {
   return buildModelsUrl(getBaseUrl(protocol));
 }
 
+// Both official managed deployments serve /coding/v1/models; global (kimi.ai)
+// users get model discovery too, not just mainland (.com).
 export function isOfficialKimiModelsUrl(url: string): boolean {
   try {
     const parsed = new URL(url);
-    return parsed.origin === "https://api.kimi.com" && parsed.pathname === "/coding/v1/models";
+    return (
+      (parsed.origin === "https://api.kimi.com" || parsed.origin === "https://api.kimi.ai") &&
+      parsed.pathname === "/coding/v1/models"
+    );
   } catch {
     return false;
   }

package/src/oauth.ts

@@ -155,7 +155,14 @@ async function lockStoredOAuthCredential(
   };
 }
 
-import { CLIENT_ID, PROVIDER_ID, RETRYABLE_REFRESH_STATUSES, getOAuthHost } from "./constants.ts";
+import {
+  CLIENT_ID,
+  PROVIDER_ID,
+  RETRYABLE_REFRESH_STATUSES,
+  getBaseUrl,
+  getOAuthHost,
+  normalizeKimiBaseV1,
+} from "./constants.ts";
 import { getCommonHeaders } from "./device.ts";
 import { type KimiOAuthCredentials, discoverKimiModelMetadata } from "./models.ts";
 
@@ -435,6 +442,25 @@ async function lockKimiCodeCredentials(signal?: AbortSignal): Promise<LockedKimi
   };
 }
 
+// Tokens are region-bound, but the kimi-code CLI credential file does not
+// record which OAuth host minted them — so a fresh credential reused across
+// regions (a mainland CLI login while KIMI_CODE_REGION=global, or vice versa)
+// would 401 every request. Probe the current region's managed API before
+// reuse. Only an explicit 401 disproves usability: network failures must not
+// force an unnecessary re-login. Exported for tests.
+export async function isKimiCredentialRegionValid(accessToken: string): Promise<boolean> {
+  const meUrl = `${normalizeKimiBaseV1(getBaseUrl())}/me`;
+  try {
+    const response = await fetch(meUrl, {
+      headers: { ...getCommonHeaders(), Authorization: `Bearer ${accessToken}` },
+      signal: AbortSignal.timeout(5_000),
+    });
+    return response.status !== 401;
+  } catch {
+    return true;
+  }
+}
+
 async function tryReuseKimiCliCredentials(
   callbacks: OAuthLoginCallbacks,
 ): Promise<KimiOAuthCredentials | null> {
@@ -449,6 +475,12 @@ async function tryReuseKimiCliCredentials(
   callbacks.onProgress?.("Found existing Kimi credentials, reusing them.");
 
   if (stillFresh) {
+    if (!(await isKimiCredentialRegionValid(data.access_token!))) {
+      callbacks.onProgress?.(
+        "Existing Kimi credentials are not valid for the configured region, starting a fresh login.",
+      );
+      return null;
+    }
     const extras = await discoverKimiModelMetadata(data.access_token!);
     return {
       access: data.access_token!,
@@ -461,6 +493,15 @@ async function tryReuseKimiCliCredentials(
   callbacks.onProgress?.("Kimi access token expired, refreshing.");
   try {
     const token = await refreshAccessToken(data.refresh_token!);
+    // Probe before persisting: a token that fails the region check must not
+    // be written into the shared CLI credential file, or a later CLI-side
+    // reuse (or the next /login) would pick up a token that 401s.
+    if (!(await isKimiCredentialRegionValid(token.access_token))) {
+      callbacks.onProgress?.(
+        "Refreshed Kimi credentials are not valid for the configured region, starting a fresh login.",
+      );
+      return null;
+    }
     const expiresMs = Date.now() + token.expires_in * 1000;
     writeKimiCodeCredentials(token.access_token, token.refresh_token, expiresMs);
     const extras = await discoverKimiModelMetadata(token.access_token);

package/src/payload.ts

@@ -37,6 +37,8 @@ export interface KimiPayloadContext {
   cacheKey?: string;
   cacheRetention: CacheRetention;
   reasoning?: ThinkingLevel;
+  /** Per-request cap from the caller (pi options.maxTokens); wins over the omission policy. */
+  requestMaxTokens?: number;
   modelConfig: KimiResolvedModelConfig;
 }
 
@@ -264,6 +266,155 @@ async function transformOpenAIPayloadFiles(
   }
 }
 
+// -----------------------------------------------------------------------------
+// Per-request inline media budget (upstream kimi-code #3784,
+// mediaResolverService.applyMediaBudget): accumulated inline media count
+// against a 20 MB per-request base64 wire-size budget (not decoded media
+// bytes); when exceeded, the oldest items are dropped until the total is under
+// the 10 MB base64 wire-size low-water mark and replaced with an omission
+// placeholder. OpenAI data URLs count the full data: URL string, including its
+// small prefix overhead, while Anthropic base64 blocks count the source data
+// string. Uploaded ms:// references are tiny and never counted. Media is
+// deduped by content hash so a repeated image counts once and every occurrence
+// is dropped together.
+// -----------------------------------------------------------------------------
+
+const REQUEST_MEDIA_BUDGET_BYTES = 20 * 1024 * 1024;
+const REQUEST_MEDIA_BUDGET_LOW_BYTES = 10 * 1024 * 1024;
+
+interface InlineMediaBudgetEntry {
+  kind: "image" | "video";
+  key: string;
+  bytes: number;
+  /** Indices into messages[...].content[...] (a third index addresses a tool_result's content). */
+  path: number[];
+}
+
+function inlineMediaKey(kind: string, payload: string): string {
+  return createHash("sha256").update(kind).update("\0").update(payload).digest("hex");
+}
+
+function collectOpenAIInlineMedia(payload: JsonRecord): InlineMediaBudgetEntry[] {
+  const entries: InlineMediaBudgetEntry[] = [];
+  if (!Array.isArray(payload.messages)) return entries;
+  for (const [messageIndex, message] of payload.messages.entries()) {
+    if (!isRecord(message) || !Array.isArray(message.content)) continue;
+    for (const [blockIndex, block] of (message.content as unknown[]).entries()) {
+      if (!isRecord(block)) continue;
+      const field =
+        block.type === "image_url" ? "image_url" : block.type === "video_url" ? "video_url" : null;
+      if (!field) continue;
+      const kind = block.type === "image_url" ? "image" : "video";
+      const value = block[field];
+      const url =
+        typeof value === "string"
+          ? value
+          : isRecord(value) && typeof value.url === "string"
+            ? value.url
+            : null;
+      if (!url || !url.startsWith("data:")) continue;
+      entries.push({
+        kind,
+        key: inlineMediaKey(kind, url),
+        bytes: url.length,
+        path: [messageIndex, blockIndex],
+      });
+    }
+  }
+  return entries;
+}
+
+function collectAnthropicInlineMedia(payload: JsonRecord): InlineMediaBudgetEntry[] {
+  const entries: InlineMediaBudgetEntry[] = [];
+  if (!Array.isArray(payload.messages)) return entries;
+  const collect = (messageIndex: number, path: number[], block: unknown): void => {
+    if (!isRecord(block)) return;
+    const kind = block.type === "image" || block.type === "video" ? block.type : null;
+    if (
+      kind &&
+      isRecord(block.source) &&
+      block.source.type === "base64" &&
+      typeof block.source.media_type === "string" &&
+      typeof block.source.data === "string"
+    ) {
+      const data = block.source.data;
+      entries.push({
+        kind,
+        key: inlineMediaKey(kind, `${block.source.media_type}\0${data}`),
+        bytes: data.length,
+        path: [messageIndex, ...path],
+      });
+    }
+  };
+  for (const [messageIndex, message] of payload.messages.entries()) {
+    if (!isRecord(message) || !Array.isArray(message.content)) continue;
+    for (const [blockIndex, block] of (message.content as unknown[]).entries()) {
+      if (isRecord(block) && block.type === "tool_result" && Array.isArray(block.content)) {
+        for (const [nestedIndex, nested] of (block.content as unknown[]).entries()) {
+          collect(messageIndex, [blockIndex, nestedIndex], nested);
+        }
+        continue;
+      }
+      collect(messageIndex, [blockIndex], block);
+    }
+  }
+  return entries;
+}
+
+export function applyInlineMediaBudget(
+  payload: JsonRecord,
+  api: "anthropic-messages" | "openai-completions",
+  budgetBytes: number = REQUEST_MEDIA_BUDGET_BYTES,
+  lowBytes: number = REQUEST_MEDIA_BUDGET_LOW_BYTES,
+): boolean {
+  const entries =
+    api === "anthropic-messages"
+      ? collectAnthropicInlineMedia(payload)
+      : collectOpenAIInlineMedia(payload);
+  if (entries.length === 0) return false;
+
+  // Deduplicate by content: repeated media counts once, drops hit every copy.
+  const bytesByKey = new Map<string, number>();
+  for (const entry of entries) {
+    if (!bytesByKey.has(entry.key)) bytesByKey.set(entry.key, entry.bytes);
+  }
+  let total = 0;
+  for (const bytes of bytesByKey.values()) total += bytes;
+  if (total <= budgetBytes) return false;
+
+  const dropped = new Set<string>();
+  for (const [key, bytes] of bytesByKey) {
+    if (total <= lowBytes) break;
+    if (bytes === 0) continue;
+    dropped.add(key);
+    total -= bytes;
+  }
+
+  const messages = payload.messages as unknown[];
+  let droppedCount = 0;
+  for (const entry of entries) {
+    if (!dropped.has(entry.key)) continue;
+    const message = messages[entry.path[0]] as JsonRecord;
+    const content = message.content as unknown[];
+    const placeholder = {
+      type: "text",
+      text: `[${entry.kind} omitted: dropped to fit the request media budget]`,
+    };
+    if (entry.path.length === 2) {
+      content[entry.path[1]] = placeholder;
+    } else {
+      const toolResult = content[entry.path[1]] as JsonRecord;
+      (toolResult.content as unknown[])[entry.path[2]] = placeholder;
+    }
+    droppedCount += 1;
+  }
+  console.warn(
+    `[kimi-coding] inline media exceeded the ${String(budgetBytes / (1024 * 1024))} MB ` +
+      `per-request budget; ${String(droppedCount)} media item(s) omitted`,
+  );
+  return true;
+}
+
 function isEffectivelyEmptyOpenAIContent(content: unknown): boolean {
   if (typeof content === "string") return content.trim() === "";
   if (!Array.isArray(content)) return false;
@@ -472,6 +623,75 @@ async function transformAnthropicPayloadFiles(
 
 const RESPONSES_EFFORTS = new Set(["low", "high", "max"]);
 
+// Empty/whitespace-only text parts in the Responses `input` array. Assistant
+// turns that produced no text (reasoning + tool calls only) replay as
+// output_text:"" and upstream 400s on text non-emptiness; see issue #78.
+const RESPONSES_TEXT_PART_TYPES = new Set(["output_text", "text", "input_text"]);
+
+function isEmptyTextPart(part: unknown): boolean {
+  return (
+    isRecord(part) &&
+    typeof part.type === "string" &&
+    RESPONSES_TEXT_PART_TYPES.has(part.type) &&
+    (typeof part.text !== "string" || part.text.trim() === "")
+  );
+}
+
+export function stripEmptyResponsesTextParts(payload: JsonRecord): boolean {
+  if (!Array.isArray(payload.input)) return false;
+  let changed = false;
+  const input: unknown[] = [];
+  for (const item of payload.input) {
+    if (!isRecord(item)) {
+      input.push(item);
+      continue;
+    }
+    // Typed non-message items (function_call, reasoning, ...) pass through.
+    if (typeof item.type === "string" && item.type !== "message") {
+      input.push(item);
+      continue;
+    }
+    const role = item.role;
+    const content = item.content;
+    const isAssistantLike = role === "assistant" || role == null;
+    if (typeof content === "string") {
+      if (isAssistantLike && content.trim() === "") {
+        changed = true;
+        continue;
+      }
+      input.push(item);
+      continue;
+    }
+    if (!Array.isArray(content)) {
+      // A message item with missing/non-array content carries nothing to
+      // render; drop assistant-shaped ones instead of replaying a
+      // contentless message (the upstream 400 path this fix targets).
+      if (isAssistantLike && (content === undefined || content === null)) {
+        changed = true;
+        continue;
+      }
+      input.push(item);
+      continue;
+    }
+    const next = content.filter((part) => !isEmptyTextPart(part));
+    // An assistant message with nothing left — either filtered here or
+    // arriving empty — carries no information; drop it rather than send a
+    // contentless message. User/system messages keep their content.
+    if (next.length === 0 && isAssistantLike) {
+      changed = true;
+      continue;
+    }
+    if (next.length === content.length) {
+      input.push(item);
+      continue;
+    }
+    changed = true;
+    input.push({ ...item, content: next });
+  }
+  if (changed) payload.input = input;
+  return changed;
+}
+
 function responsesSupportedEfforts(ctx: KimiPayloadContext): string[] {
   const advertised = ctx.modelConfig.supportEfforts;
   if (advertised?.length) return advertised.filter((effort) => RESPONSES_EFFORTS.has(effort));
@@ -547,6 +767,19 @@ export async function applyKimiPayloadMutations(
     );
   }
 
+  // 1b. Responses wire: drop empty text parts replayed from text-less
+  // assistant turns (issue #78). pi-ai's Responses serializer keeps empty
+  // output_text blocks — unlike its Chat Completions serializer, which
+  // filters them — so a reasoning/tool-only turn is replayed as
+  // {role:"assistant", content:[{type:"output_text", text:""}]} on every
+  // subsequent request, and upstream endpoints reject the whole payload with
+  // a 400-class text-non-emptiness error. function_call / reasoning / all
+  // other part types are untouched; an assistant message left with no
+  // content is dropped entirely.
+  if (ctx.api === "openai-responses") {
+    stripEmptyResponsesTextParts(payload);
+  }
+
   // 2. File upload dispatch (protocol-specific).
   if (ctx.upload) {
     const uploadCache = ctx.uploadCacheScope ? uploadedFileCache : new Map<string, string>();
@@ -557,6 +790,11 @@ export async function applyKimiPayloadMutations(
       await transformAnthropicPayloadFiles(payload, ctx.upload, uploadCache, uploadCacheScope);
     }
   }
+  if (ctx.api === "openai-completions" || ctx.api === "anthropic-messages") {
+    // Runs after the upload transforms so media already promoted to ms://
+    // references (tiny URLs) are never counted against the budget.
+    applyInlineMediaBudget(payload, ctx.api);
+  }
   if (ctx.api === "openai-completions") {
     normalizeOpenAIAssistantToolCalls(payload);
   }
@@ -590,8 +828,12 @@ export async function applyKimiPayloadMutations(
 
   // 5. Spread extra_body into the top-level payload before normalization and
   //    config caps. Top-level fields retain precedence over extra_body.
+  let extraBodyHadCap = false;
   if (isRecord(payload.extra_body)) {
     const extraBody = payload.extra_body as JsonRecord;
+    extraBodyHadCap = ["max_tokens", "max_completion_tokens", "max_output_tokens"].some(
+      (key) => typeof extraBody[key] === "number",
+    );
     delete payload.extra_body;
     for (const [key, value] of Object.entries(extraBody)) {
       if (payload[key] === undefined) {
@@ -620,6 +862,29 @@ export async function applyKimiPayloadMutations(
   }
 
   const generation = ctx.modelConfig.generation;
+  // Output cap policy (mirrors upstream kimi-code #4091): omit the completion
+  // cap on the OpenAI wires unless explicitly configured. pi-ai seeds a cap
+  // clamped to the context window (clampMaxTokensToContext), and forwarding
+  // that value breaks strict serving stacks (e.g. bare vLLM) that reject a
+  // cap above the model's real output limit with repeated 400s. A cap counts
+  // as explicit when generation.maxCompletionTokens is configured
+  // (KIMI_MODEL_MAX_COMPLETION_TOKENS / config generation.maxCompletionTokens),
+  // model.maxTokens holds a non-window value, or the caller supplies a
+  // per-request cap through options.maxTokens / extra_body. Anthropic /messages requires
+  // max_tokens, so that wire keeps pi-ai's window-clamped cap — the same
+  // window - usedContextTokens value upstream fills in when unset.
+  if (ctx.api === "openai-completions" || ctx.api === "openai-responses") {
+    const capKey = ctx.api === "openai-responses" ? "max_output_tokens" : "max_completion_tokens";
+    const explicitModelCap =
+      typeof ctx.modelConfig.maxTokens === "number" &&
+      ctx.modelConfig.maxTokens > 0 &&
+      ctx.modelConfig.maxTokens !== ctx.modelConfig.contextWindow;
+    const explicitRequestCap =
+      extraBodyHadCap || (typeof ctx.requestMaxTokens === "number" && ctx.requestMaxTokens > 0);
+    if (generation.maxCompletionTokens === undefined && !explicitModelCap && !explicitRequestCap) {
+      delete payload[capKey];
+    }
+  }
   // Official kimi-code sends temperature/top_p only when explicitly configured
   // (env KIMI_MODEL_TEMPERATURE / KIMI_MODEL_TOP_P → generation.*); otherwise it
   // omits them and lets the server apply its own defaults. Mirror that exactly:
@@ -720,7 +985,7 @@ export async function applyKimiPayloadMutations(
     }
   }
 
-  // 8. K2.7 Code API constraints: the server rejects tool_choice "required" /
+  // 8. Kimi coding endpoint constraints: the server rejects tool_choice "required" /
   //    function-specific when thinking is enabled (always-on). Responses only
   //    accepts auto. temperature/top_p are handled in step 6 — omitted unless
   //    explicitly configured, matching the official kimi-code client rather

package/src/settings-ui.ts

@@ -58,6 +58,13 @@ export function setProtocol(
   return { ...config, protocol };
 }
 
+export function setRegion(
+  config: KimiCodeConfig,
+  region: KimiCodeConfig["region"],
+): KimiCodeConfig {
+  return { ...config, region };
+}
+
 export function setUploadThreshold(config: KimiCodeConfig, thresholdBytes: number): KimiCodeConfig {
   return { ...config, uploads: { ...config.uploads, thresholdBytes } };
 }
@@ -73,6 +80,7 @@ export function buildKimiMainTitle(
     "",
     `Model: ${modelName}`,
     `Protocol: ${config.protocol} (${sources.protocol})`,
+    `Region: ${formatRegionValue(config.region)} (${sources.region})`,
     `Upload threshold: ${formatByteSize(config.uploads.thresholdBytes)} (${sources.uploads.thresholdBytes})`,
     "",
     "Effective tools:",
@@ -138,6 +146,18 @@ export function toolMenuItem(config: KimiCodeConfig, toolName: KimiToolName): st
   return `${toolName} -> ${formatToolStatus(config, toolName)}`;
 }
 
+export function formatRegionValue(region: KimiCodeConfig["region"]): string {
+  return region ?? "auto";
+}
+
+export function formatRegionStatus(config: KimiCodeConfig): string {
+  return `region: ${formatRegionValue(config.region)}`;
+}
+
+export function regionMenuItem(config: KimiCodeConfig): string {
+  return `Region -> ${formatRegionValue(config.region)}`;
+}
+
 export function protocolMenuItem(config: KimiCodeConfig): string {
   return `Protocol -> ${config.protocol}`;
 }

package/src/stream.ts

@@ -360,6 +360,7 @@ export function streamSimpleKimi(
             cacheKey,
             cacheRetention,
             reasoning: options?.reasoning,
+            requestMaxTokens: options?.maxTokens,
             modelConfig,
           });
           if (

package/src/tools/common.ts

@@ -1,7 +1,7 @@
 import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 
-import { PROVIDER_ID, getBaseUrl } from "../constants.ts";
+import { PROVIDER_ID, getBaseUrl, normalizeKimiBaseV1 } from "../constants.ts";
 import { getKimiProviderHeaders } from "../device.ts";
 import {
   KIMI_LOGIN_REQUIRED_MESSAGE,
@@ -57,8 +57,7 @@ export function buildTimeoutSignal(signal: AbortSignal | undefined): {
 }
 
 export function getKimiBaseV1(): string {
-  const base = getBaseUrl().replace(/\/+$/, "");
-  return base.endsWith("/v1") ? base : `${base}/v1`;
+  return normalizeKimiBaseV1(getBaseUrl());
 }
 
 export function getKimiDatasourceUrl(): string {

package/src/usage.ts

@@ -1,4 +1,4 @@
-import { PROVIDER_ID, getBaseUrl } from "./constants.ts";
+import { PROVIDER_ID, getBaseUrl, normalizeKimiBaseV1 } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
 import { readStoredOAuthCredential, refreshKimiAuthToken } from "./oauth.ts";
 
@@ -51,6 +51,13 @@ function toNumber(value: unknown): number | null {
   return Number.isFinite(number) ? number : null;
 }
 
+function toOptionalNumber(value: unknown): number | null {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || !value.trim()) return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
 function toStringValue(value: unknown): string | undefined {
   if (typeof value === "string" && value.trim()) return value;
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
@@ -141,6 +148,85 @@ function formatExtraUsage(info: BoosterWalletInfo): string[] {
   return lines;
 }
 
+// Quota model (upstream kimi-code #3787): the platform /usages payload now
+// serves per-window used ratios under `usages` instead of absolute used/limit
+// rows. Keys are snake_case (`limit_5h`, `limit_7d`, `limit_month_total`,
+// `limit_month_code`); each entry carries `used_ratio` (0..1, sometimes a
+// decimal string) and an optional `reset_time`. Rows are presence-driven —
+// the backend omits windows the plan does not have. The legacy `usage` /
+// `limits` rows are still served alongside during the transition, but the
+// legacy wire is gone from kap-server, so quota rows win when present.
+interface QuotaEntry {
+  usedRatio: number;
+  resetTime?: string;
+}
+
+const QUOTA_WINDOWS = [
+  ["limit_5h", "5h limit"],
+  ["limit_7d", "Weekly limit"],
+  ["limit_month_total", "Monthly limit"],
+] as const;
+
+const QUOTA_MONTH_CODE_KEY = "limit_month_code";
+
+function isRecordValue(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function toRatio(value: unknown): number | undefined {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : undefined;
+  }
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : undefined;
+}
+
+function parseQuotaEntry(value: unknown): QuotaEntry | undefined {
+  if (!isRecordValue(value)) return undefined;
+  const usedRatio = toRatio(value.used_ratio);
+  if (usedRatio === undefined) return undefined;
+  const resetTime = toStringValue(value.reset_time);
+  return {
+    usedRatio,
+    ...(resetTime ? { resetTime } : {}),
+  };
+}
+
+function parseQuotaWindows(record: Record<string, unknown>): Map<string, QuotaEntry> {
+  const windows = new Map<string, QuotaEntry>();
+  const usages = record.usages;
+  if (!isRecordValue(usages)) return windows;
+  for (const key of [...QUOTA_WINDOWS.map(([key]) => key), QUOTA_MONTH_CODE_KEY]) {
+    const entry = parseQuotaEntry(usages[key]);
+    if (entry) windows.set(key, entry);
+  }
+  return windows;
+}
+
+function formatQuotaRow(label: string, entry: QuotaEntry, options: UsageFormatOptions): string {
+  const percent = Math.min(100, Math.max(0, Math.ceil(entry.usedRatio * 100)));
+  const lines = [label, `${quotaBar(entry.usedRatio * 100, 100)} ${percent}% used`];
+  const reset = formatResetTime(entry.resetTime, options);
+  if (reset) lines.push(`Resets ${reset}`);
+  return lines.join("\n");
+}
+
+// The kimi/code split of the monthly quota on the new plan: `code` is the
+// code-typed share of the monthly total as served, `kimi` the remainder
+// (mirrors upstream monthlyBreakdown in apps/kimi-code usage-format).
+function formatMonthlyBreakdown(
+  total: QuotaEntry,
+  windows: Map<string, QuotaEntry>,
+): string | null {
+  const code = windows.get(QUOTA_MONTH_CODE_KEY);
+  if (!code) return null;
+  const codePercent = Math.min(100, Math.max(0, Math.ceil(code.usedRatio * 100)));
+  const totalPercent = Math.min(100, Math.max(0, Math.ceil(total.usedRatio * 100)));
+  const kimiPercent = Math.max(0, totalPercent - codePercent);
+  return `kimi ${kimiPercent}% · code ${codePercent}%`;
+}
+
 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>;
@@ -164,11 +250,28 @@ export function parseUsageSummary(payload: unknown, options: UsageFormatOptions
 
   const record = payload as Record<string, unknown>;
   const lines: string[] = [];
-  const summary = parseUsageRow(record.usage, "Current week");
+
+  const quotaWindows = parseQuotaWindows(record);
+  // A code-split entry without a monthly total renders no row of its own; it
+  // only feeds the breakdown line, so it must not suppress the legacy rows.
+  const hasQuotaRows = QUOTA_WINDOWS.some(([key]) => quotaWindows.has(key));
+  if (hasQuotaRows) {
+    for (const [key, label] of QUOTA_WINDOWS) {
+      const entry = quotaWindows.get(key);
+      if (!entry) continue;
+      if (lines.length > 0) lines.push("");
+      lines.push(...formatQuotaRow(label, entry, options).split("\n"));
+      const breakdown =
+        key === "limit_month_total" ? formatMonthlyBreakdown(entry, quotaWindows) : null;
+      if (breakdown) lines.push(breakdown);
+    }
+  }
+
+  const summary = hasQuotaRows ? null : parseUsageRow(record.usage, "Current week");
   if (summary)
     lines.push(formatUsageRow({ ...summary, label: normalizeUsageLabel(summary.label) }, options));
 
-  if (Array.isArray(record.limits)) {
+  if (!hasQuotaRows && Array.isArray(record.limits)) {
     for (const [index, item] of record.limits.entries()) {
       const itemRecord =
         typeof item === "object" && item !== null && !Array.isArray(item)
@@ -307,8 +410,7 @@ function partialBlock(value: number): string {
 }
 
 export function buildKimiUsageUrl(baseUrl = getBaseUrl("openai")): string {
-  const normalized = baseUrl.replace(/\/+$/, "");
-  return normalized.endsWith("/v1") ? `${normalized}/usages` : `${normalized}/v1/usages`;
+  return `${normalizeKimiBaseV1(baseUrl)}/usages`;
 }
 
 function fetchKimiUsage(token: string, signal: AbortSignal): Promise<Response> {
@@ -383,6 +485,12 @@ export interface KimiUserInfo {
   userLevel: number;
   userLevelName: string;
   email?: string;
+  /**
+   * Plan generation from the managed /me profile (upstream #3921). upstream
+   * gates feedback surveys and plan-dependent surfaces by it; the monthly
+   * kimi/code quota split only exists on newer goods versions.
+   */
+  goodsVersion?: number;
 }
 
 export function parseKimiUserInfo(payload: unknown): KimiUserInfo | null {
@@ -391,12 +499,14 @@ export function parseKimiUserInfo(payload: unknown): KimiUserInfo | null {
   const userId = toStringValue(record.user_id);
   if (!userId) return null;
   const email = toStringValue(record.email);
+  const goodsVersion = toOptionalNumber(record.goods_version);
   return {
     userId,
     nickname: toStringValue(record.nickname) ?? "",
     userLevel: toNumber(record.user_level) ?? 0,
     userLevelName: toStringValue(record.user_level_name) ?? "",
     ...(email ? { email } : {}),
+    ...(goodsVersion !== null ? { goodsVersion } : {}),
   };
 }
 
@@ -412,8 +522,7 @@ export function formatKimiUserInfo(info: KimiUserInfo): string {
 }
 
 export function buildKimiUserInfoUrl(baseUrl = getBaseUrl("openai")): string {
-  const normalized = baseUrl.replace(/\/+$/, "");
-  return normalized.endsWith("/v1") ? `${normalized}/me` : `${normalized}/v1/me`;
+  return `${normalizeKimiBaseV1(baseUrl)}/me`;
 }
 
 function fetchKimiUserInfo(token: string, signal: AbortSignal): Promise<Response> {