pi-provider-kimi-code 0.3.1 → 0.4.0

package/index.ts

@@ -7,952 +7,377 @@
  * Usage:
  *   pi -e ~/workshop/pi-provider-kimi-code
  *   # Then /login kimi-coding, or set KIMI_API_KEY=...
+ *
+ * Source layout:
+ *   src/constants.ts  — module-level consts + env-driven configuration
+ *   src/device.ts     — device id + kimi-cli-compatible request headers
+ *   src/oauth.ts      — device flow, token refresh, kimi-cli reuse,
+ *                       login/refresh handlers, stream-level auth refresh
+ *   src/models.ts     — /v1/models discovery + extras-merging helpers
+ *   src/payload.ts    — payload pipeline + file upload + transforms
+ *   src/stream.ts     — empty-response filter + streamSimpleKimi orchestrator
  */
 
-import { execSync } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import { dirname, join } from "node:path";
-import type {
-  OAuthCredentials,
-  OAuthLoginCallbacks,
-  AssistantMessageEvent,
-  CacheRetention,
-  Context,
-  Model,
-  SimpleStreamOptions,
-  ThinkingLevel,
-} from "@mariozechner/pi-ai";
+import type { Api, Model } from "@earendil-works/pi-ai";
 import {
-  streamSimpleAnthropic,
-  streamSimpleOpenAICompletions,
-  AssistantMessageEventStream,
-} from "@mariozechner/pi-ai";
-import type { ExtensionAPI, OAuthCredential } from "@mariozechner/pi-coding-agent";
-import { AuthStorage } from "@mariozechner/pi-coding-agent";
-
-// =============================================================================
-// Constants
-// =============================================================================
-
-const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
-const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
-const PROTOCOL =
-  process.env.KIMI_CODE_PROTOCOL === "openai" ? "openai-completions" : "anthropic-messages";
-// Use a custom api identifier so this provider never conflicts with the
-// built-in "anthropic-messages" or "openai-completions" stream handlers.
-const KIMI_API_TYPE = PROTOCOL === "openai-completions" ? "kimi-openai-completions" : "kimi-anthropic-messages";
-const DEFAULT_BASE_URL =
-  PROTOCOL === "openai-completions"
-    ? "https://api.kimi.com/coding/v1"
-    : "https://api.kimi.com/coding";
-const KIMI_CLI_VERSION = "1.30.0";
-const KIMI_CLI_USER_AGENT = `KimiCLI/${KIMI_CLI_VERSION}`;
-const KIMI_PLATFORM = "kimi_cli";
-const DEVICE_ID_PATH = join(os.homedir(), ".pi", "providers", "kimi-coding", "device_id");
-
-// =============================================================================
-// Device identification
-// =============================================================================
-
-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;
-}
-
-function getBaseUrl(): string {
-  const value = process.env.KIMI_CODE_BASE_URL || DEFAULT_BASE_URL;
-  return value.trim() || DEFAULT_BASE_URL;
-}
-
-function createDeviceId(): string {
-  return randomBytes(16).toString("hex");
-}
-
-function ensurePrivateFile(path: string): void {
-  try {
-    chmodSync(path, 0o600);
-  } catch {
-    // Ignore chmod failures on platforms/filesystems that do not support it.
-  }
-}
+  AuthStorage,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import os from "node:os";
+import { relative } from "node:path";
 
-function readPersistedDeviceId(): string | null {
-  try {
-    if (!existsSync(DEVICE_ID_PATH)) return null;
-    const deviceId = readFileSync(DEVICE_ID_PATH, "utf8").trim();
-    return deviceId || null;
-  } catch {
-    return null;
+import {
+  type KimiCodeConfig,
+  getProjectKimiCodeConfigPath,
+  getGlobalKimiCodeConfigPath,
+  loadHomeKimiCodeConfig,
+  loadKimiCodeConfig,
+  loadProjectKimiCodeConfig,
+  saveHomeKimiCodeConfig,
+  saveProjectKimiCodeConfig,
+} from "./src/config.ts";
+import {
+  DEFAULT_KIMI_MODEL_INPUT,
+  KIMI_API_TYPE,
+  PROVIDER_ID,
+  getBaseUrl,
+} from "./src/constants.ts";
+import { getCommonHeaders } from "./src/device.ts";
+import {
+  type KimiOAuthCredentials,
+  applyKimiEnvOverridesToModel,
+  applyKimiOAuthExtrasToModel,
+} from "./src/models.ts";
+import { loginKimiCode, refreshKimiCodeToken } from "./src/oauth.ts";
+import { streamSimpleKimi } from "./src/stream.ts";
+import { buildMoonshotFetchTool, buildMoonshotSearchTool } from "./src/tools/moonshot.ts";
+
+const MOONSHOT_TOOL_NAMES = ["moonshot_search", "moonshot_fetch"] as const;
+type MoonshotToolName = (typeof MOONSHOT_TOOL_NAMES)[number];
+type KimiConfigScope = "project" | "home";
+const MEMBERSHIP_LEVEL_NAMES: Record<string, string> = {
+  LEVEL_FREE: "Free",
+  LEVEL_BASIC: "Adagio",
+  LEVEL_STANDARD: "Moderato",
+  LEVEL_INTERMEDIATE: "Allegretto",
+  LEVEL_ADVANCED: "Allegro",
+  LEVEL_PREMIUM: "Vivace",
+};
+
+interface UsageRow {
+  label: string;
+  used: number;
+  limit: number;
+}
+
+function registerConfiguredMoonshotTools(
+  pi: ExtensionAPI,
+  config: KimiCodeConfig,
+  options: { updateActiveTools: boolean },
+): void {
+  if (config.tools.moonshot_search.enabled) {
+    pi.registerTool(
+      buildMoonshotSearchTool({
+        defaultCollapsed: config.tools.moonshot_search.default_collapsed,
+      }),
+    );
   }
-}
-
-function persistDeviceId(deviceId: string): void {
-  try {
-    mkdirSync(dirname(DEVICE_ID_PATH), { recursive: true });
-    writeFileSync(DEVICE_ID_PATH, deviceId, "utf8");
-    ensurePrivateFile(DEVICE_ID_PATH);
-  } catch {
-    // Ignore persistence failures and fall back to the in-memory device id.
+  if (config.tools.moonshot_fetch.enabled) {
+    pi.registerTool(
+      buildMoonshotFetchTool({
+        defaultCollapsed: config.tools.moonshot_fetch.default_collapsed,
+      }),
+    );
   }
-}
 
-function getMacOSVersion(): string {
-  try {
-    return execSync("sw_vers -productVersion", { encoding: "utf8" }).trim();
-  } catch {
-    return os.release();
-  }
-}
+  if (!options.updateActiveTools) return;
 
-function getDeviceModel(): string {
-  const platform = process.platform;
-  const arch = os.machine() || process.arch;
-  if (platform === "darwin") {
-    const version = getMacOSVersion();
-    return version && arch ? `macOS ${version} ${arch}` : `macOS ${arch}`;
-  }
-  if (platform === "win32") {
-    // Only show the major release (e.g. "Windows 10", "Windows 11") to match
-    // the upstream kimi-cli behavior in `def _device_model() -> str:`.
-    // See: https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/auth/oauth.py
-    const parts = os.release().split(".");
-    let release = parts[0];
-    if (release === "10" && parts.length >= 3) {
-      const build = parseInt(parts[2], 10);
-      if (!isNaN(build) && build >= 22000) {
-        release = "11";
-      }
+  const activeTools = new Set(pi.getActiveTools());
+  for (const toolName of MOONSHOT_TOOL_NAMES) {
+    if (config.tools[toolName].enabled) {
+      activeTools.add(toolName);
+    } else {
+      activeTools.delete(toolName);
     }
-    return release && arch ? `Windows ${release} ${arch}` : `Windows ${arch}`;
   }
-  // Normalize platform name to match Python `platform.system()` casing used by
-  // upstream kimi-cli (e.g. "Linux", "FreeBSD", "SunOS"), since Node's
-  // `process.platform` is always lower-case.
-  const SYSTEM_NAME: Record<string, string> = {
-    aix: "AIX",
-    freebsd: "FreeBSD",
-    linux: "Linux",
-    openbsd: "OpenBSD",
-    sunos: "SunOS",
-  };
-  const system = SYSTEM_NAME[platform] ?? platform;
-  const release = os.release();
-  return release && arch ? `${system} ${release} ${arch}` : `${system} ${arch}`;
-}
-
-function asciiHeaderValue(value: string, fallback = "unknown"): string {
-  const trimmed = value.trim();
-  /* oxlint-disable-next-line no-control-regex */
-  if (/^[\x00-\x7F]*$/.test(trimmed)) {
-    return trimmed;
-  }
-  /* oxlint-disable-next-line no-control-regex */
-  const sanitized = trimmed.replace(/[^\x00-\x7F]/g, "").trim();
-  return sanitized || fallback;
-}
-
-const DEVICE_MODEL = getDeviceModel();
-let DEVICE_ID: string | null = null;
-
-function getStableDeviceId(): string {
-  if (DEVICE_ID) {
-    return DEVICE_ID;
-  }
-
-  const persisted = readPersistedDeviceId();
-  if (persisted) {
-    DEVICE_ID = persisted;
-    return DEVICE_ID;
-  }
-
-  DEVICE_ID = createDeviceId();
-  persistDeviceId(DEVICE_ID);
-  return DEVICE_ID;
-}
-
-function getCommonHeaders(): Record<string, string> {
-  const headers = {
-    "User-Agent": KIMI_CLI_USER_AGENT,
-    "X-Msh-Platform": KIMI_PLATFORM,
-    "X-Msh-Version": KIMI_CLI_VERSION,
-    "X-Msh-Device-Name": os.hostname(),
-    "X-Msh-Device-Model": DEVICE_MODEL,
-    "X-Msh-Os-Version": os.release(),
-    "X-Msh-Device-Id": getStableDeviceId(),
-  };
-  return Object.fromEntries(
-    Object.entries(headers).map(([key, value]) => [key, asciiHeaderValue(value)]),
-  ) as Record<string, string>;
+  pi.setActiveTools([...activeTools]);
 }
 
-// =============================================================================
-// OAuth Implementation
-// =============================================================================
-
-interface DeviceAuthorization {
-  user_code: string;
-  device_code: string;
-  verification_uri: string;
-  verification_uri_complete: string;
-  expires_in: number;
-  interval: number;
+function getKimiUsageToken(): string | null {
+  const credential = AuthStorage.create().get(PROVIDER_ID);
+  if (credential?.type === "oauth" && credential.access) return credential.access;
+  const apiKey = process.env.KIMI_API_KEY?.trim();
+  return apiKey || null;
 }
 
-interface TokenResponse {
-  access_token: string;
-  refresh_token: string;
-  expires_in: number;
-  scope: string;
-  token_type: string;
+function toNumber(value: unknown): number | null {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
 }
 
-async function requestDeviceAuthorization(): Promise<DeviceAuthorization> {
-  const response = await fetch(`${getOAuthHost()}/api/oauth/device_authorization`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-      ...getCommonHeaders(),
-    },
-    body: new URLSearchParams({
-      client_id: CLIENT_ID,
-    }),
-  });
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(`Device authorization failed: ${response.status} ${text}`);
-  }
-
-  const data = (await response.json()) as {
-    user_code?: string;
-    device_code?: string;
-    verification_uri?: string;
-    verification_uri_complete?: string;
-    expires_in?: number;
-    interval?: number;
-  };
-
-  if (!data.user_code || !data.device_code || !data.verification_uri_complete) {
-    throw new Error("Invalid device authorization response");
-  }
-
+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>;
+  const limit = toNumber(record.limit);
+  const usedValue = toNumber(record.used);
+  const remaining = toNumber(record.remaining);
+  const used = usedValue ?? (limit !== null && remaining !== null ? limit - remaining : null);
+  if (limit === null && used === null) return null;
   return {
-    user_code: data.user_code,
-    device_code: data.device_code,
-    verification_uri: data.verification_uri || "",
-    verification_uri_complete: data.verification_uri_complete,
-    expires_in: data.expires_in || 1800,
-    interval: data.interval || 5,
+    label: String(record.name || record.title || fallbackLabel),
+    used: used ?? 0,
+    limit: limit ?? 0,
   };
 }
 
-async function requestDeviceToken(auth: DeviceAuthorization): Promise<TokenResponse | null> {
-  const response = await fetch(`${getOAuthHost()}/api/oauth/token`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-      ...getCommonHeaders(),
-    },
-    body: new URLSearchParams({
-      client_id: CLIENT_ID,
-      device_code: auth.device_code,
-      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-    }),
-  });
-
-  if (response.status === 200) {
-    const data = (await response.json()) as TokenResponse;
-    if (data.access_token && data.refresh_token) {
-      return data;
-    }
-    throw new Error("Token response missing required fields");
+function parseUsageSummary(payload: unknown): string {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+    return "Usage: unavailable";
   }
 
-  if (response.status === 400) {
-    const data = (await response.json()) as { error?: string; error_description?: string };
-    if (data.error === "authorization_pending") {
-      return null;
+  const record = payload as Record<string, unknown>;
+  const lines: string[] = [];
+  const membership = parseMembership(record);
+  if (membership) lines.push(membership);
+
+  const rows: UsageRow[] = [];
+  const summary = parseUsageRow(record.usage, "Weekly limit");
+  if (summary) rows.push(summary);
+
+  if (Array.isArray(record.limits)) {
+    for (const [index, item] of record.limits.entries()) {
+      const detail =
+        typeof item === "object" && item !== null && !Array.isArray(item)
+          ? ((item as Record<string, unknown>).detail ?? item)
+          : item;
+      const row = parseUsageRow(detail, index === 0 ? "5h rate limit" : `Limit #${index + 1}`);
+      if (row) rows.push(row);
     }
-    if (data.error === "expired_token") {
-      throw new Error("expired_token");
-    }
-    throw new Error(`Token request failed: ${data.error_description || data.error || "unknown"}`);
   }
 
-  const text = await response.text().catch(() => "");
-  throw new Error(`Token request failed: ${response.status} ${text}`);
+  lines.push(...rows.map(formatUsageRow));
+  return lines.length === 0 ? "Usage: no usage data" : lines.join("\n");
 }
 
-async function refreshAccessToken(refreshToken: string): Promise<TokenResponse> {
-  const response = await fetch(`${getOAuthHost()}/api/oauth/token`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-      ...getCommonHeaders(),
-    },
-    body: new URLSearchParams({
-      client_id: CLIENT_ID,
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-    }),
-  });
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    if (response.status === 401 || response.status === 403) {
-      throw new Error(`Token refresh unauthorized: ${text}`);
-    }
-    throw new Error(`Token refresh failed: ${response.status} ${text}`);
-  }
-
-  const data = (await response.json()) as TokenResponse;
-  if (!data.access_token || !data.refresh_token) {
-    throw new Error("Token refresh response missing required fields");
+function parseMembership(record: Record<string, unknown>): string | null {
+  const user = record.user;
+  if (typeof user !== "object" || user === null || Array.isArray(user)) return null;
+  const membership = (user as Record<string, unknown>).membership;
+  if (typeof membership !== "object" || membership === null || Array.isArray(membership)) {
+    return null;
   }
-
-  return data;
+  const level = (membership as Record<string, unknown>).level;
+  if (typeof level !== "string" || !level) return null;
+  const name = MEMBERSHIP_LEVEL_NAMES[level];
+  return name ? `Membership: ${name} (${level})` : `Membership: ${level}`;
 }
 
-// =============================================================================
-// OAuth login / refresh for extension registration
-// =============================================================================
-
-async function loginKimiCode(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
-  // Keep trying until we get a token (handles expired device codes)
-  while (true) {
-    const auth = await requestDeviceAuthorization();
-
-    callbacks.onAuth({
-      url: auth.verification_uri_complete,
-      instructions: `Please visit the URL to authorize. Your code: ${auth.user_code}`,
-    });
-
-    const interval = Math.max(auth.interval, 1) * 1000;
-    const expiresAt = Date.now() + auth.expires_in * 1000;
-
-    let token: TokenResponse | null = null;
-    let printedWaiting = false;
-
-    while (Date.now() < expiresAt) {
-      try {
-        token = await requestDeviceToken(auth);
-        if (token) break;
-      } catch (error) {
-        if (error instanceof Error && error.message === "expired_token") {
-          // Device code expired, restart the flow
-          if (callbacks.onProgress) {
-            callbacks.onProgress("Device code expired, restarting...");
-          }
-          break;
-        }
-        throw error;
-      }
-
-      if (!printedWaiting) {
-        if (callbacks.onProgress) {
-          callbacks.onProgress("Waiting for authorization...");
-        }
-        printedWaiting = true;
-      }
-
-      // Check for abort
-      if (callbacks.signal?.aborted) {
-        throw new Error("Authorization aborted");
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-
-    if (token) {
-      return {
-        access: token.access_token,
-        refresh: token.refresh_token,
-        expires: Date.now() + token.expires_in * 1000,
-      };
-    }
-
-    // If we get here without a token, the device code expired - loop will retry
-  }
+function formatUsageRow(row: UsageRow): string {
+  if (row.limit <= 0) return `${row.label}: ${row.used} used`;
+  const remaining = Math.max(0, Math.min(row.limit - row.used, row.limit));
+  const percent = Math.round((remaining / row.limit) * 100);
+  return `${row.label}: ${quotaBar(remaining, row.limit)} ${percent}% left (${remaining}/${row.limit})`;
 }
 
-async function refreshKimiCodeToken(credentials: OAuthCredentials): Promise<OAuthCredentials> {
-  const token = await refreshAccessToken(credentials.refresh);
-  return {
-    access: token.access_token,
-    refresh: token.refresh_token,
-    expires: Date.now() + token.expires_in * 1000,
-  };
+function quotaBar(remaining: number, limit: number): string {
+  const width = 20;
+  const filled = Math.max(0, Math.min(width, Math.round((remaining / limit) * width)));
+  return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
 }
 
-// =============================================================================
-// Payload / stream helpers: types + pure utilities
-// =============================================================================
-
-const EMPTY_RESPONSE_PREFIX = "(Empty response:";
-const DEFAULT_KIMI_INLINE_UPLOAD_THRESHOLD_BYTES = 1 * 1024 * 1024;
+async function fetchKimiUsageSummary(): Promise<string> {
+  const token = getKimiUsageToken();
+  if (!token) return "Usage: missing credentials. Run /login kimi-coding.";
 
-type JsonRecord = Record<string, unknown>;
-type Uploader = (mimeType: string, data: string) => Promise<string | null>;
-
-interface KimiEnvOverrides {
-  temperature?: number;
-  topP?: number;
-  maxTokens?: number;
-}
-
-function resolveCacheRetention(value?: CacheRetention): CacheRetention {
-  if (value === "none" || value === "short" || value === "long") return value;
-  if (process.env.PI_CACHE_RETENTION === "long") return "long";
-  return "short";
-}
-
-interface KimiPayloadContext {
-  api: "anthropic-messages" | "openai-completions";
-  upload?: Uploader;
-  cacheKey?: string;
-  cacheRetention: CacheRetention;
-  reasoning?: ThinkingLevel;
-  envOverrides: KimiEnvOverrides;
-}
-
-function isRecord(value: unknown): value is JsonRecord {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function mapThinkingLevel(level?: string): { effort: string | null; enabled: boolean } | undefined {
-  if (!level) return undefined;
-  if (level === "none" || level === "off") return { effort: null, enabled: false };
-  if (level === "minimal" || level === "low") return { effort: "low", enabled: true };
-  if (level === "medium") return { effort: "medium", enabled: true };
-  if (level === "high" || level === "xhigh") return { effort: "high", enabled: true };
-  return undefined;
-}
-
-function parseInlineUploadThreshold(raw: string | undefined): number {
-  const parsed = Number.parseInt(raw ?? "", 10);
-  return Number.isFinite(parsed) && parsed >= 0
-    ? parsed
-    : DEFAULT_KIMI_INLINE_UPLOAD_THRESHOLD_BYTES;
-}
-
-function deriveFilesBaseUrl(baseUrl: string): string {
-  const trimmed = baseUrl.replace(/\/$/, "");
-  return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15_000);
+  try {
+    const response = await fetch("https://api.kimi.com/coding/v1/usages", {
+      method: "GET",
+      headers: {
+        ...getCommonHeaders(),
+        Authorization: `Bearer ${token}`,
+      },
+      signal: controller.signal,
+    });
+    if (!response.ok) return `Usage: fetch failed (${response.status})`;
+    return parseUsageSummary(await response.json());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `Usage: fetch failed (${message})`;
+  } finally {
+    clearTimeout(timeout);
+  }
 }
 
-function parseDataUrl(url: string): { mimeType: string; data: string } | null {
-  const match = url.match(/^data:([^;,]+);base64,([A-Za-z0-9+/=]+)$/);
-  return match ? { mimeType: match[1], data: match[2] } : null;
+function moonshotStatus(config: KimiCodeConfig): string {
+  return MOONSHOT_TOOL_NAMES.map((toolName) => {
+    const tool = config.tools[toolName];
+    const enabled = tool.enabled ? "enabled" : "disabled";
+    const collapsed = tool.default_collapsed ? "collapsed" : "expanded";
+    return `${toolName}: ${enabled}, default ${collapsed}`;
+  }).join("\n");
 }
 
-function getUploadFilename(mimeType: string): string {
-  const map: Record<string, string> = {
-    "image/jpeg": "upload.jpg",
-    "image/png": "upload.png",
-    "image/gif": "upload.gif",
-    "image/webp": "upload.webp",
-    "video/mp4": "upload.mp4",
-    "video/quicktime": "upload.mov",
+function toggleEnabled(config: KimiCodeConfig, toolName: MoonshotToolName): KimiCodeConfig {
+  return {
+    tools: {
+      ...config.tools,
+      [toolName]: {
+        ...config.tools[toolName],
+        enabled: !config.tools[toolName].enabled,
+      },
+    },
   };
-  return map[mimeType] ?? (mimeType.startsWith("video/") ? "upload.mp4" : "upload.bin");
 }
 
-function readEnvOverrides(): KimiEnvOverrides {
-  const out: KimiEnvOverrides = {};
-  const temp = process.env.KIMI_MODEL_TEMPERATURE;
-  if (temp) out.temperature = parseFloat(temp);
-  const topP = process.env.KIMI_MODEL_TOP_P;
-  if (topP) out.topP = parseFloat(topP);
-  const maxTokens = process.env.KIMI_MODEL_MAX_TOKENS;
-  if (maxTokens) out.maxTokens = parseInt(maxTokens, 10);
-  return out;
+function toggleCollapsed(config: KimiCodeConfig, toolName: MoonshotToolName): KimiCodeConfig {
+  return {
+    tools: {
+      ...config.tools,
+      [toolName]: {
+        ...config.tools[toolName],
+        default_collapsed: !config.tools[toolName].default_collapsed,
+      },
+    },
+  };
 }
 
-// =============================================================================
-// File upload (I/O edge)
-// =============================================================================
-
-async function uploadKimiFile(
-  apiKey: string,
-  mimeType: string,
-  data: string,
-): Promise<string | null> {
-  const buffer = Buffer.from(data, "base64");
-  const isVideo = mimeType.startsWith("video/");
-  const threshold = parseInlineUploadThreshold(process.env.KIMI_CODE_UPLOAD_THRESHOLD_BYTES);
-  if (!isVideo && buffer.length <= threshold) return null;
-
-  const filename = getUploadFilename(mimeType);
-  const formData = new FormData();
-  formData.append("file", new Blob([buffer], { type: mimeType }), filename);
-  formData.append("purpose", isVideo ? "video" : "image");
-
-  const baseUrl = process.env.KIMI_CODE_BASE_URL || DEFAULT_BASE_URL;
-  const uploadUrl = `${deriveFilesBaseUrl(baseUrl)}/files`;
-  const debug = process.env.KIMI_CODE_DEBUG === "1";
-  if (debug) {
-    console.log(
-      `\n[kimi-coding] Uploading ${filename} to ${uploadUrl} (${(buffer.length / 1024 / 1024).toFixed(2)} MB)`,
-    );
-  }
-
-  try {
-    const response = await fetch(uploadUrl, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${apiKey}`, ...getCommonHeaders() },
-      body: formData,
-    });
-    if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
-    const fileObj = (await response.json()) as { id?: string };
-    if (!fileObj.id) throw new Error("missing file id");
-    const fileUrl = `ms://${fileObj.id}`;
-    if (debug) console.log(`[kimi-coding] Upload success: ${fileUrl}`);
-    return fileUrl;
-  } catch (err) {
-    console.error("[kimi-coding] Upload failed:", err);
-    return null;
-  }
-}
+async function runKimiCommand(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<void> {
+  let config = loadKimiCodeConfig({ cwd: ctx.cwd, home: os.homedir() });
+  let usage = await fetchKimiUsageSummary();
+  ctx.ui.notify(usage);
 
-// =============================================================================
-// Payload file transformers (pure given an Uploader)
-// =============================================================================
-// These walk the provider-specific payload shape and replace inline base64
-// image/video blocks with ms:// references returned by the injected uploader.
-// They take an Uploader rather than an apiKey so they can be unit-tested with
-// a fake uploader; all network I/O stays behind that boundary.
-
-async function transformOpenAIPayloadFiles(payload: JsonRecord, upload: Uploader): Promise<void> {
-  if (!Array.isArray(payload.messages)) return;
-  const cache = new Map<string, string>();
-
-  for (const message of payload.messages) {
-    if (!isRecord(message) || !Array.isArray(message.content)) continue;
-
-    for (const block of message.content) {
-      if (!isRecord(block)) continue;
-      const key =
-        block.type === "image_url" ? "image_url" : block.type === "video_url" ? "video_url" : null;
-      if (!key) continue;
-
-      const field = block[key];
-      const urlValue =
-        typeof field === "string"
-          ? field
-          : isRecord(field) && typeof field.url === "string"
-            ? field.url
-            : null;
-      if (!urlValue || urlValue.startsWith("ms://")) continue;
-
-      const parsed = parseDataUrl(urlValue);
-      if (!parsed) continue;
-
-      const uploaded = cache.get(urlValue) ?? (await upload(parsed.mimeType, parsed.data));
-      if (!uploaded) continue;
-      cache.set(urlValue, uploaded);
-
-      block[key] =
-        typeof field === "string" ? uploaded : { ...(field as JsonRecord), url: uploaded };
+  while (true) {
+    const choice = await ctx.ui.select(buildKimiMainTitle(config, ctx.cwd), [
+      `Edit project config (${relative(ctx.cwd, getProjectKimiCodeConfigPath(ctx.cwd))})`,
+      `Edit home config (${homeRelative(getGlobalKimiCodeConfigPath(os.homedir()))})`,
+      "Refresh usage",
+      "Done",
+    ]);
+
+    if (!choice || choice === "Done") return;
+    if (choice === "Refresh usage") {
+      usage = await fetchKimiUsageSummary();
+      ctx.ui.notify(usage);
+      continue;
+    }
+    if (choice.startsWith("Edit project config")) {
+      config = await editConfigScope(pi, ctx, "project");
+    } else if (choice.startsWith("Edit home config")) {
+      config = await editConfigScope(pi, ctx, "home");
     }
   }
 }
 
-async function transformAnthropicPayloadFiles(
-  payload: JsonRecord,
-  upload: Uploader,
-): Promise<void> {
-  if (!Array.isArray(payload.messages)) return;
-  const cache = new Map<string, string>();
-
-  const transformImageBlock = async (block: unknown): Promise<unknown> => {
-    if (!isRecord(block) || block.type !== "image") return block;
-    const source = block.source;
-    if (!isRecord(source) || source.type !== "base64") return block;
-    const mediaType = source.media_type;
-    const data = source.data;
-    if (typeof mediaType !== "string" || typeof data !== "string") return block;
-
-    const cacheKey = `${mediaType}:${data}`;
-    const uploaded = cache.get(cacheKey) ?? (await upload(mediaType, data));
-    if (!uploaded) return block;
-    cache.set(cacheKey, uploaded);
-
-    const next: JsonRecord = { type: "image", source: { type: "url", url: uploaded } };
-    if (block.cache_control !== undefined) next.cache_control = block.cache_control;
-    return next;
-  };
-
-  for (const message of payload.messages) {
-    if (!isRecord(message) || !Array.isArray(message.content)) continue;
-
-    for (let i = 0; i < message.content.length; i++) {
-      const block = message.content[i];
-      if (isRecord(block) && block.type === "tool_result" && Array.isArray(block.content)) {
-        for (let j = 0; j < block.content.length; j++) {
-          block.content[j] = await transformImageBlock(block.content[j]);
-        }
-        continue;
-      }
-      message.content[i] = await transformImageBlock(block);
+async function editConfigScope(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  scope: KimiConfigScope,
+): Promise<KimiCodeConfig> {
+  let current = loadScopeKimiCodeConfig(scope, ctx.cwd);
+  while (true) {
+    const choice = await ctx.ui.select(buildConfigScopeTitle(scope, current, ctx.cwd), [
+      toolMenuItem(current, "moonshot_search"),
+      toolMenuItem(current, "moonshot_fetch"),
+      "Back",
+    ]);
+    if (!choice || choice === "Back") {
+      return loadKimiCodeConfig({ cwd: ctx.cwd, home: os.homedir() });
+    }
+    if (choice.startsWith("moonshot_search")) {
+      current = await editMoonshotTool(pi, ctx, scope, current, "moonshot_search");
+    } else if (choice.startsWith("moonshot_fetch")) {
+      current = await editMoonshotTool(pi, ctx, scope, current, "moonshot_fetch");
     }
   }
 }
 
-// =============================================================================
-// Payload mutation pipeline
-// =============================================================================
-// Applies all Kimi-specific mutations to a provider payload in place.
-// Pure given its context: no process.env / fs / network access of its own —
-// every side effect enters via ctx.upload or pre-read values in ctx.
-// This makes the five steps below testable with fixture payloads.
-
-async function applyKimiPayloadMutations(
-  payload: JsonRecord,
-  ctx: KimiPayloadContext,
-): Promise<void> {
-  // 1. Map unsupported roles: Kimi does not recognize "developer" (OpenAI-specific).
-  if (Array.isArray(payload.messages)) {
-    payload.messages = payload.messages.map((msg) =>
-      isRecord(msg) && msg.role === "developer" ? { ...msg, role: "system" } : msg,
+async function editMoonshotTool(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  scope: KimiConfigScope,
+  config: KimiCodeConfig,
+  toolName: MoonshotToolName,
+): Promise<KimiCodeConfig> {
+  let current = config;
+  while (true) {
+    const tool = current.tools[toolName];
+    const choice = await ctx.ui.select(
+      `Edit ${toolName}\n\n${formatToolStatus(current, toolName)}`,
+      [
+        tool.enabled ? `Disable ${toolName}` : `Enable ${toolName}`,
+        tool.default_collapsed ? "Expand previews by default" : "Collapse previews by default",
+        "Back",
+      ],
     );
-  }
-
-  // 2. File upload dispatch (protocol-specific).
-  if (ctx.upload) {
-    if (ctx.api === "openai-completions") {
-      await transformOpenAIPayloadFiles(payload, ctx.upload);
-    } else if (ctx.api === "anthropic-messages") {
-      await transformAnthropicPayloadFiles(payload, ctx.upload);
-    }
-  }
-
-  // 3. prompt_cache_key injection. Respect any key already on the payload,
-  //    otherwise fall back to the caller-provided cacheKey (sessionId or
-  //    explicit options.prompt_cache_key override). Skipped entirely when
-  //    cacheRetention is "none" (via options.cacheRetention or
-  //    PI_CACHE_RETENTION) so callers can truly disable caching — otherwise
-  //    Kimi's native session cache would still fire even if pi-ai's
-  //    Anthropic-style cache_control markers are omitted.
-  if (ctx.cacheRetention !== "none") {
-    const existing = payload.prompt_cache_key;
-    const resolved = (typeof existing === "string" && existing) || ctx.cacheKey;
-    if (resolved) payload.prompt_cache_key = resolved;
-  }
-
-  // 4. Env-level hyperparameter overrides (pre-parsed into numbers by caller).
-  const { temperature, topP, maxTokens } = ctx.envOverrides;
-  if (temperature !== undefined) payload.temperature = temperature;
-  if (topP !== undefined) payload.top_p = topP;
-  if (maxTokens !== undefined) payload.max_tokens = maxTokens;
-
-  // 5. Reasoning effort mapping.
-  if (ctx.reasoning) {
-    const mapped = mapThinkingLevel(ctx.reasoning);
-    if (mapped) {
-      payload.reasoning_effort = mapped.effort;
-      const extraBody = isRecord(payload.extra_body) ? payload.extra_body : {};
-      extraBody.thinking = { type: mapped.enabled ? "enabled" : "disabled" };
-      payload.extra_body = extraBody;
+    if (!choice || choice === "Back") return current;
+    if (choice.startsWith("Enable") || choice.startsWith("Disable")) {
+      current = toggleEnabled(current, toolName);
+    } else if (choice.endsWith("previews by default")) {
+      current = toggleCollapsed(current, toolName);
     }
+    saveScopeKimiCodeConfig(scope, ctx.cwd, current);
+    const effective = loadKimiCodeConfig({ cwd: ctx.cwd, home: os.homedir() });
+    registerConfiguredMoonshotTools(pi, effective, { updateActiveTools: true });
+    ctx.ui.notify(`Saved ${toolName} config`, "info");
   }
 }
 
-// =============================================================================
-// Event stream filter: suppress Kimi "(Empty response: ...)" text blocks
-// =============================================================================
-// The Kimi API wraps thinking-only responses (no text content) into a text
-// block like: (Empty response: {'content': [{'type': 'thinking', ...}]}).
-// This leaks internal state to the user. We buffer text_start/text_delta
-// events and drop the whole block if text_end starts with the marker.
-// Pure async generator — no closure dependencies, testable with synthetic
-// event arrays.
-
-async function* filterEmptyResponseStream(
-  upstream: AsyncIterable<AssistantMessageEvent>,
-): AsyncIterable<AssistantMessageEvent> {
-  const suppressedIndices = new Set<number>();
-  let textBuffer: AssistantMessageEvent[] = [];
-  let bufferingIndex: number | null = null;
-
-  for await (const event of upstream) {
-    // Start buffering when a new text block begins.
-    if (event.type === "text_start") {
-      bufferingIndex = event.contentIndex;
-      textBuffer = [event];
-      continue;
-    }
-
-    // Accumulate text deltas + detect the empty-response marker on text_end.
-    if (
-      bufferingIndex !== null &&
-      "contentIndex" in event &&
-      event.contentIndex === bufferingIndex
-    ) {
-      if (event.type === "text_delta") {
-        textBuffer.push(event);
-        continue;
-      }
-      if (event.type === "text_end") {
-        if (event.content.startsWith(EMPTY_RESPONSE_PREFIX)) {
-          // Suppress entire text block. Do NOT splice the message content
-          // array: it is a shared reference into session state, and mutating
-          // it would shift subsequent contentIndex values, corrupting the
-          // stream.
-          suppressedIndices.add(bufferingIndex);
-        } else {
-          // Legitimate text block — flush buffered events + end event.
-          for (const buffered of textBuffer) yield buffered;
-          yield event;
-        }
-        textBuffer = [];
-        bufferingIndex = null;
-        continue;
-      }
-    }
-
-    // Skip any event targeting an already-suppressed content index.
-    if ("contentIndex" in event && suppressedIndices.has(event.contentIndex)) {
-      continue;
-    }
-
-    // Clean suppressed blocks out of the final message.
-    if (event.type === "done" && suppressedIndices.size > 0) {
-      event.message.content = event.message.content.filter(
-        (block) =>
-          !(
-            block.type === "text" &&
-            typeof block.text === "string" &&
-            block.text.startsWith(EMPTY_RESPONSE_PREFIX)
-          ),
-      );
-    }
+function loadScopeKimiCodeConfig(scope: KimiConfigScope, cwd: string): KimiCodeConfig {
+  if (scope === "project") return loadProjectKimiCodeConfig(cwd);
+  return loadHomeKimiCodeConfig(os.homedir());
+}
 
-    yield event;
+function saveScopeKimiCodeConfig(
+  scope: KimiConfigScope,
+  cwd: string,
+  config: KimiCodeConfig,
+): void {
+  if (scope === "project") {
+    saveProjectKimiCodeConfig(cwd, config);
+  } else {
+    saveHomeKimiCodeConfig(os.homedir(), config);
   }
 }
 
-// =============================================================================
-// Auth refresh: recover from server-side token invalidation
-// =============================================================================
-// pi-coding-agent only refreshes an OAuth token when the locally cached
-// `expires` is in the past. If the server rotates/revokes the access token
-// before that (common with short-lived session tokens), every request keeps
-// returning 401. We detect that situation by inspecting the first event of
-// the upstream stream, force a refresh through AuthStorage (which persists
-// the new credentials under a file lock), and retry once.
-
-const PROVIDER_ID = "kimi-coding";
-
-async function refreshKimiAuthToken(currentKey: string): Promise<string | null> {
-  try {
-    const storage = AuthStorage.create();
-    const cred = storage.get(PROVIDER_ID);
-    if (!cred || cred.type !== "oauth") {
-      console.error(
-        `[kimi-coding] auth refresh skipped: no OAuth credentials for ${PROVIDER_ID} on disk`,
-      );
-      return null;
-    }
-
-    // If disk already has a different valid token (e.g., another process or a
-    // previous retry refreshed it while the caller's in-memory cache went
-    // stale), reuse it without hitting the OAuth endpoint.
-    if (cred.access !== currentKey && Date.now() < cred.expires) {
-      console.error("[kimi-coding] auth refresh: reusing newer on-disk token");
-      return cred.access;
-    }
-
-    console.error("[kimi-coding] auth refresh: requesting new access token");
-    const refreshed = await refreshAccessToken(cred.refresh);
-    const newCred: OAuthCredential = {
-      type: "oauth",
-      access: refreshed.access_token,
-      refresh: refreshed.refresh_token,
-      expires: Date.now() + refreshed.expires_in * 1000,
-    };
-    storage.set(PROVIDER_ID, newCred);
-    console.error("[kimi-coding] auth refresh: new token persisted");
-    return newCred.access;
-  } catch (err) {
-    console.error("[kimi-coding] auth refresh failed:", err);
-    return null;
-  }
+function buildKimiMainTitle(_config: KimiCodeConfig, _cwd: string): string {
+  return "Kimi settings";
 }
 
-// =============================================================================
-// Stream wrapper: orchestrates payload mutation + event filter
-// =============================================================================
-// Reads every side-effect source (process.env, options, apiKey) at the top
-// and hands a plain KimiPayloadContext to applyKimiPayloadMutations. The only
-// thing this function itself "does" is wire SDK streaming + filter + error
-// fallback; the actual logic lives in the pure units above.
-
-function streamSimpleKimi(
-  model: Model<"anthropic-messages" | "openai-completions">,
-  context: Context,
-  options?: SimpleStreamOptions,
-): AssistantMessageEventStream {
-  const filtered = new AssistantMessageEventStream();
-  const initialKey = options?.apiKey || process.env.KIMI_API_KEY || "";
-
-  const cacheKeyOverride = (
-    options as (SimpleStreamOptions & { prompt_cache_key?: unknown }) | undefined
-  )?.prompt_cache_key;
-  const cacheKey = (typeof cacheKeyOverride === "string" && cacheKeyOverride) || options?.sessionId;
-  const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-  const envOverrides = readEnvOverrides();
-  const originalOnPayload = options?.onPayload;
-
-  const buildPatchedOptions = (apiKey: string): SimpleStreamOptions => {
-    const upload: Uploader | undefined = apiKey
-      ? (mimeType, data) => uploadKimiFile(apiKey, mimeType, data)
-      : undefined;
-    // Only forward apiKey if we actually have one — never override the
-    // caller's credential (e.g. Claude Code OAuth token) with an empty string.
-    const apiKeyOverride = apiKey ? { apiKey } : {};
-    return {
-      ...options,
-      ...apiKeyOverride,
-      onPayload: async (payload, modelData) => {
-        let nextPayload: unknown = payload;
-
-        if (isRecord(nextPayload)) {
-          await applyKimiPayloadMutations(nextPayload, {
-            api: model.api,
-            upload,
-            cacheKey,
-            cacheRetention,
-            reasoning: options?.reasoning,
-            envOverrides,
-          });
-        }
-
-        if (originalOnPayload) {
-          const res = await originalOnPayload(nextPayload, modelData);
-          if (res !== undefined) nextPayload = res;
-        }
-
-        return nextPayload;
-      },
-    };
-  };
+function buildConfigScopeTitle(
+  scope: KimiConfigScope,
+  config: KimiCodeConfig,
+  cwd: string,
+): string {
+  const path =
+    scope === "project"
+      ? relative(cwd, getProjectKimiCodeConfigPath(cwd))
+      : homeRelative(getGlobalKimiCodeConfigPath(os.homedir()));
+  return [`Edit ${scope} config`, `File: ${path}`, "", moonshotStatus(config)].join("\n");
+}
 
-  void (async () => {
-    let attempt = 0;
-    let currentKey = initialKey;
-
-    while (true) {
-      const patchedOptions = buildPatchedOptions(currentKey);
-      // Route by the module-level PROTOCOL, not model.api, since we register
-      // with a custom api type (kimi-openai-completions / kimi-anthropic-messages)
-      // to avoid overriding the built-in Anthropic/OpenAI stream handlers.
-      const upstream =
-        PROTOCOL === "openai-completions"
-          ? streamSimpleOpenAICompletions(
-              model as Model<"openai-completions">,
-              context,
-              patchedOptions,
-            )
-          : streamSimpleAnthropic(model as Model<"anthropic-messages">, context, patchedOptions);
-
-      let shouldRetry = false;
-      let prefixBuffer: AssistantMessageEvent[] = [];
-
-      try {
-        for await (const event of filterEmptyResponseStream(upstream)) {
-          // streamAnthropic emits a synthetic "start" event synchronously,
-          // before the for-await loop begins iterating and therefore before
-          // the HTTP request is actually made.  If the request 401s, the loop
-          // throws and the catch block emits "error".  Without buffering, the
-          // "start" event (which carries an empty AssistantMessage) leaks into
-          // the session history and the TUI, leaving a phantom empty assistant
-          // bubble.  We buffer "start" events and only flush them once we see
-          // a non-error event that proves the stream is alive.
-          if (event.type === "start") {
-            prefixBuffer.push(event);
-            continue;
-          }
-
-          // Speculative OAuth refresh on the first error.  We retry once so
-          // that short-lived Kimi tokens invalidated by the server before the
-          // local expires timestamp lapses don't surface as raw 401s to the
-          // user.  Non-auth errors still trigger one wasted refresh, but the
-          // retried request fails the same way and we forward it.
-          if (attempt === 0 && event.type === "error") {
-            console.error(
-              `[kimi-coding] upstream error on first event, attempting refresh: ${event.error?.errorMessage?.slice(0, 200)}`,
-            );
-            const refreshed = await refreshKimiAuthToken(currentKey);
-            if (refreshed && refreshed !== currentKey) {
-              console.error("[kimi-coding] retrying stream with refreshed token");
-              currentKey = refreshed;
-              shouldRetry = true;
-              break; // discard prefixBuffer — don't leak the stale start
-            }
-            console.error(
-              "[kimi-coding] refresh did not yield a new token, forwarding original error",
-            );
-          }
-
-          // First non-start, non-retry event: flush buffered prefix, then
-          // stream normally.
-          for (const e of prefixBuffer) filtered.push(e);
-          prefixBuffer = [];
-          filtered.push(event);
-        }
-
-        // Stream ended normally: flush any remaining buffered starts.
-        for (const e of prefixBuffer) filtered.push(e);
-      } catch (err) {
-        // Upstream threw rather than emitting a stream `error` event. This can
-        // be the same stale-token 401 surfaced as an exception (depending on
-        // the SDK path / network layer), so mirror the in-stream refresh
-        // branch: on attempt 0, try one OAuth refresh + retry. Either way,
-        // discard `prefixBuffer` — we never confirmed the stream actually
-        // started, and flushing the buffered `start` would resurrect the
-        // phantom empty assistant message this PR set out to fix.
-        console.error("[kimi-coding] stream error:", err);
-        if (attempt === 0) {
-          const refreshed = await refreshKimiAuthToken(currentKey);
-          if (refreshed && refreshed !== currentKey) {
-            console.error("[kimi-coding] retrying stream after thrown error with refreshed token");
-            currentKey = refreshed;
-            shouldRetry = true;
-          }
-        }
-        if (!shouldRetry) {
-          filtered.push({
-            type: "error",
-            reason: "error",
-            error: {
-              content: [],
-              stopReason: "error",
-              usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
-            },
-          } as AssistantMessageEvent & { type: "error" });
-        }
-      }
-
-      if (shouldRetry) {
-        attempt++;
-        continue;
-      }
-      break;
-    }
-  })();
+function homeRelative(filePath: string): string {
+  const home = os.homedir();
+  return filePath.startsWith(`${home}/`) ? `~/${filePath.slice(home.length + 1)}` : filePath;
+}
 
-  return filtered;
+function toolMenuItem(config: KimiCodeConfig, toolName: MoonshotToolName): string {
+  return `${toolName} -> ${formatToolStatus(config, toolName)}`;
 }
 
-// =============================================================================
-// Extension Entry Point
-// =============================================================================
+function formatToolStatus(config: KimiCodeConfig, toolName: MoonshotToolName): string {
+  const tool = config.tools[toolName];
+  const enabled = tool.enabled ? "enabled" : "disabled";
+  const collapsed = tool.default_collapsed ? "default collapsed" : "default expanded";
+  return `${enabled}, ${collapsed}`;
+}
 
 export default function (pi: ExtensionAPI) {
-  pi.registerProvider("kimi-coding", {
+  const config = loadKimiCodeConfig({ cwd: process.cwd(), home: os.homedir() });
+
+  pi.registerProvider(PROVIDER_ID, {
     baseUrl: getBaseUrl(),
     apiKey: "KIMI_API_KEY",
     api: KIMI_API_TYPE,
@@ -961,15 +386,15 @@ export default function (pi: ExtensionAPI) {
     headers: getCommonHeaders(),
 
     models: [
-      {
+      applyKimiEnvOverridesToModel({
         id: "kimi-for-coding",
         name: "Kimi for Coding",
         reasoning: true,
-        input: ["text", "image", "video"],
+        input: [...DEFAULT_KIMI_MODEL_INPUT] as unknown as ("text" | "image")[],
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         contextWindow: 262144,
         maxTokens: 32000,
-      },
+      } as Model<Api>),
     ],
 
     oauth: {
@@ -977,6 +402,27 @@ export default function (pi: ExtensionAPI) {
       login: loginKimiCode,
       refreshToken: refreshKimiCodeToken,
       getApiKey: (cred) => cred.access,
+      // Reflect server-side model identity on the registered model after login
+      // / refresh. We never rewrite the model id (pi-side `/model` selections
+      // and persisted sessions reference it); only the human-facing name, the
+      // context window, and an out-of-band `wireModelId` carried into the
+      // request payload by streamSimpleKimi.
+      modifyModels: (models, cred) => {
+        const extras = cred as KimiOAuthCredentials;
+        return models.map((model) => {
+          if (model.id !== "kimi-for-coding") return model;
+          return applyKimiEnvOverridesToModel(applyKimiOAuthExtrasToModel(model, extras));
+        });
+      },
+    },
+  });
+
+  registerConfiguredMoonshotTools(pi, config, { updateActiveTools: false });
+
+  pi.registerCommand("kimi-settings", {
+    description: "Show Kimi usage and configure optional Kimi tools",
+    handler: async (_args, ctx) => {
+      await runKimiCommand(pi, ctx);
     },
   });
 }