pi-provider-kimi-code 0.6.12 → 0.6.14

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.14";
 
 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/errors.ts

@@ -0,0 +1,31 @@
+// Kimi error-message classification, mirroring upstream kimi-code #4477 /
+// #4703: quota exhaustion is a hard limit with explicit non-retryability, not
+// a transient rate limit — say so instead of letting the raw 429 body read
+// like something a retry would fix.
+
+const QUOTA_ERROR_CODE = "exceeded_current_quota_error";
+
+/**
+ * Detect Kimi's structured quota error in a flattened error message
+ * (status line + JSON body). Both markers are required to avoid matching
+ * unrelated 429 rate limits, which ARE transient.
+ */
+export function isKimiQuotaExhaustedMessage(message: unknown): boolean {
+  const text = String(message ?? "").toLowerCase();
+  return text.includes(QUOTA_ERROR_CODE) && /\b429\b/.test(text);
+}
+
+/**
+ * Rewrite a raw upstream error into actionable text. Returns the input
+ * unchanged when nothing applies.
+ */
+export function improveKimiErrorMessage(message: string): string {
+  if (!isKimiQuotaExhaustedMessage(message)) return message;
+  return (
+    "Kimi Code quota exhausted (HTTP 429, exceeded_current_quota_error). " +
+    "This is a hard quota limit, not a transient rate limit — retrying will " +
+    "keep failing until the quota window resets. Run /kimi-settings to check " +
+    "your current usage. " +
+    `Original error: ${message}`
+  );
+}

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
@@ -175,6 +184,13 @@ interface KimiServerModel {
   supports_thinking_type?: unknown;
   protocol?: unknown;
   think_efforts?: unknown;
+  // Unified schema (upstream kimi-code #4209). The server currently sends
+  // both shapes; the official client already reads ONLY these fields, so
+  // prefer them and treat the flat legacy fields above as fallback.
+  limit?: unknown;
+  reasoning?: unknown;
+  modalities?: unknown;
+  tools?: unknown;
 }
 
 function parseSupportsThinkingType(value: unknown): "only" | "no" | "both" | undefined {
@@ -212,28 +228,89 @@ function parseThinkEfforts(value: unknown): {
   };
 }
 
+// Unified `reasoning` object: { type: "only" | "both" | "none", effort: {
+// valid: [...], default } }. A missing object means the legacy flat fields
+// decide; a present object always wins (type "none" clears a stale thinking
+// default, matching upstream's three-state mapping to internal "no").
+function parseUnifiedReasoning(value: unknown): {
+  readonly matched: boolean;
+  readonly supportsThinkingType?: "only" | "no" | "both";
+  readonly supportsReasoning?: boolean;
+  readonly supportEfforts?: string[];
+  readonly defaultEffort?: string;
+} {
+  if (!isRecord(value)) return { matched: false };
+  const rawType = value.type;
+  const supportsThinkingType =
+    rawType === "only" || rawType === "both" ? rawType : rawType === "none" ? "no" : undefined;
+  const effort = isRecord(value.effort) ? value.effort : undefined;
+  const supportEfforts = Array.isArray(effort?.valid)
+    ? effort.valid.filter((e): e is string => typeof e === "string" && !!e)
+    : undefined;
+  const rawDefault =
+    typeof effort?.default === "string" && effort.default ? effort.default : undefined;
+  // A default not listed in valid is dropped, same as upstream.
+  const defaultEffort =
+    rawDefault && supportEfforts && !supportEfforts.includes(rawDefault) ? undefined : rawDefault;
+  return {
+    matched: true,
+    ...(supportsThinkingType ? { supportsThinkingType } : {}),
+    supportsReasoning: supportsThinkingType !== undefined && supportsThinkingType !== "no",
+    ...(supportEfforts && supportEfforts.length > 0 ? { supportEfforts } : {}),
+    ...(defaultEffort ? { defaultEffort } : {}),
+  };
+}
+
+function parseInputModalities(value: unknown): {
+  supportsImageIn?: boolean;
+  supportsVideoIn?: boolean;
+} {
+  if (!isRecord(value) || !Array.isArray(value.input)) return {};
+  const input = value.input;
+  return {
+    supportsImageIn: input.includes("image"),
+    supportsVideoIn: input.includes("video"),
+  };
+}
+
 function parseKimiModelMetadata(model: KimiServerModel): KimiModelMetadata | undefined {
   if (typeof model.id !== "string" || !model.id) return undefined;
   const metadata: KimiModelMetadata = { wireModelId: model.id };
   if (typeof model.display_name === "string") metadata.modelDisplay = model.display_name;
-  if (typeof model.context_length === "number" && model.context_length > 0) {
+  // Unified limit.context wins over legacy context_length.
+  const limit = isRecord(model.limit) ? model.limit : undefined;
+  if (typeof limit?.context === "number" && limit.context > 0) {
+    metadata.contextLength = limit.context;
+  } else if (typeof model.context_length === "number" && model.context_length > 0) {
     metadata.contextLength = model.context_length;
   }
-  const thinkingType = parseSupportsThinkingType(model.supports_thinking_type);
-  if (thinkingType) {
-    metadata.supportsThinkingType = thinkingType;
-  } else if (typeof model.supports_reasoning === "boolean") {
-    metadata.supportsReasoning = model.supports_reasoning;
-  }
-  if (typeof model.supports_image_in === "boolean") {
-    metadata.supportsImageIn = model.supports_image_in;
+  const unifiedReasoning = parseUnifiedReasoning(model.reasoning);
+  if (unifiedReasoning.matched) {
+    const { matched: _, ...fields } = unifiedReasoning;
+    Object.assign(metadata, fields);
+  } else {
+    const thinkingType = parseSupportsThinkingType(model.supports_thinking_type);
+    if (thinkingType) {
+      metadata.supportsThinkingType = thinkingType;
+    } else if (typeof model.supports_reasoning === "boolean") {
+      metadata.supportsReasoning = model.supports_reasoning;
+    }
+    Object.assign(metadata, parseThinkEfforts(model.think_efforts));
   }
-  if (typeof model.supports_video_in === "boolean") {
-    metadata.supportsVideoIn = model.supports_video_in;
+  const modalities = parseInputModalities(model.modalities);
+  if (modalities.supportsImageIn !== undefined) {
+    metadata.supportsImageIn = modalities.supportsImageIn;
+    metadata.supportsVideoIn = modalities.supportsVideoIn;
+  } else {
+    if (typeof model.supports_image_in === "boolean") {
+      metadata.supportsImageIn = model.supports_image_in;
+    }
+    if (typeof model.supports_video_in === "boolean") {
+      metadata.supportsVideoIn = model.supports_video_in;
+    }
   }
   const protocol = parseKimiCatalogProtocol(model.protocol);
   if (protocol) metadata.protocol = protocol;
-  Object.assign(metadata, parseThinkEfforts(model.think_efforts));
   return metadata;
 }
 
@@ -246,10 +323,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";
 
@@ -211,6 +218,24 @@ export async function requestDeviceAuthorization(): Promise<DeviceAuthorization>
     throw new Error("Invalid device authorization response");
   }
 
+  // Guard against a malicious or buggy server handing us a non-web URL
+  // (file:, custom scheme, ...) that the OS URL handler would happily open.
+  // Mirrors pi 1.5.0's check for the built-in OAuth providers.
+  for (const url of [data.verification_uri, verificationUrl]) {
+    if (!url) continue;
+    let parsed: URL;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new Error("Device authorization returned an invalid verification URL");
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      throw new Error(
+        `Device authorization returned a non-web verification URL (${parsed.protocol})`,
+      );
+    }
+  }
+
   return {
     user_code: data.user_code,
     device_code: data.device_code,
@@ -435,6 +460,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 +493,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 +511,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);