pi-provider-kimi-code 0.5.1 → 0.6.1

package/index.ts

@@ -18,43 +18,43 @@
  *   src/stream.ts     — empty-response filter + streamSimpleKimi orchestrator
  */
 
-import type { Api, Model } from "@earendil-works/pi-ai";
 import {
   AuthStorage,
   type ExtensionAPI,
   type ExtensionCommandContext,
+  type ExtensionFactory,
 } from "@earendil-works/pi-coding-agent";
 import os from "node:os";
 import { relative } from "node:path";
 
 import {
   type KimiCodeConfig,
+  type KimiCodeConfigPatch,
+  KIMI_TOOL_NAMES,
   getProjectKimiCodeConfigPath,
   getGlobalKimiCodeConfigPath,
   loadHomeKimiCodeConfig,
   loadKimiCodeConfig,
+  loadKimiCodeConfigSources,
   loadProjectKimiCodeConfig,
   saveHomeKimiCodeConfig,
   saveProjectKimiCodeConfig,
+  type KimiToolName,
 } from "./src/config.ts";
-import {
-  DEFAULT_KIMI_MODEL_INPUT,
-  KIMI_API_TYPE,
-  PROVIDER_ID,
-  getBaseUrl,
-} from "./src/constants.ts";
+import { KIMI_CODE_VERSION, PROVIDER_ID, getBaseUrl, getKimiApiType } from "./src/constants.ts";
 import { getCommonHeaders } from "./src/device.ts";
 import {
   type KimiOAuthCredentials,
-  applyKimiEnvOverridesToModel,
+  type KimiOAuthExtras,
+  buildKimiModelFromConfig,
   applyKimiOAuthExtrasToModel,
+  discoverKimiModelMetadata,
+  resolveKimiModelConfig,
 } from "./src/models.ts";
-import { loginKimiCode, refreshKimiCodeToken } from "./src/oauth.ts";
-import { streamSimpleKimi } from "./src/stream.ts";
+import { loginKimiCode, refreshKimiAuthToken, refreshKimiCodeToken } from "./src/oauth.ts";
+import { setStoreResolvedKimiConfig, 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];
+import { buildKimiDatasourceTool } from "./src/tools/datasource.ts";
 type KimiConfigScope = "project" | "home";
 const MEMBERSHIP_LEVEL_NAMES: Record<string, string> = {
   LEVEL_FREE: "Free",
@@ -71,30 +71,37 @@ interface UsageRow {
   limit: number;
 }
 
+interface KimiRuntimeState {
+  cwd: string;
+  config: KimiCodeConfig;
+  modelExtras: KimiOAuthExtras;
+  overrides?: KimiCodeConfigPatch;
+}
+
+function buildKimiTool(toolName: KimiToolName, config: KimiCodeConfig) {
+  const opts = { defaultCollapsed: config.tools[toolName].default_collapsed };
+  if (toolName === "moonshot_search") return buildMoonshotSearchTool(opts);
+  if (toolName === "moonshot_fetch") return buildMoonshotFetchTool(opts);
+  if (toolName === "kimi_datasource") return buildKimiDatasourceTool(opts);
+  return undefined;
+}
+
 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,
-      }),
-    );
-  }
-  if (config.tools.moonshot_fetch.enabled) {
-    pi.registerTool(
-      buildMoonshotFetchTool({
-        defaultCollapsed: config.tools.moonshot_fetch.default_collapsed,
-      }),
-    );
+  for (const toolName of KIMI_TOOL_NAMES) {
+    if (config.tools[toolName].enabled) {
+      const tool = buildKimiTool(toolName, config);
+      if (tool) pi.registerTool(tool);
+    }
   }
 
   if (!options.updateActiveTools) return;
 
   const activeTools = new Set(pi.getActiveTools());
-  for (const toolName of MOONSHOT_TOOL_NAMES) {
+  for (const toolName of KIMI_TOOL_NAMES) {
     if (config.tools[toolName].enabled) {
       activeTools.add(toolName);
     } else {
@@ -104,6 +111,29 @@ function registerConfiguredMoonshotTools(
   pi.setActiveTools([...activeTools]);
 }
 
+function reloadEffectiveKimiRuntimeConfig(state: KimiRuntimeState, cwd: string): KimiCodeConfig {
+  const config = loadKimiCodeConfig({ cwd, home: os.homedir() }, state.overrides);
+  state.cwd = cwd;
+  state.config = config;
+  setStoreResolvedKimiConfig({
+    model: resolveKimiModelConfig(config.model, state.modelExtras),
+    protocol: config.protocol,
+    uploads: config.uploads,
+  });
+  return config;
+}
+
+function applyEffectiveKimiRuntimeConfig(
+  pi: ExtensionAPI,
+  state: KimiRuntimeState,
+  cwd: string,
+  options: { updateActiveTools: boolean },
+): KimiCodeConfig {
+  const config = reloadEffectiveKimiRuntimeConfig(state, cwd);
+  registerConfiguredMoonshotTools(pi, config, options);
+  return config;
+}
+
 function getKimiUsageToken(): string | null {
   const credential = AuthStorage.create().get(PROVIDER_ID);
   if (credential?.type === "oauth" && credential.access) return credential.access;
@@ -186,6 +216,17 @@ function quotaBar(remaining: number, limit: number): string {
   return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
 }
 
+function fetchKimiUsage(token: string, signal: AbortSignal): Promise<Response> {
+  return fetch("https://api.kimi.com/coding/v1/usages", {
+    method: "GET",
+    headers: {
+      ...getCommonHeaders(),
+      Authorization: `Bearer ${token}`,
+    },
+    signal,
+  });
+}
+
 async function fetchKimiUsageSummary(): Promise<string> {
   const token = getKimiUsageToken();
   if (!token) return "Usage: missing credentials. Run /login kimi-coding.";
@@ -193,14 +234,11 @@ async function fetchKimiUsageSummary(): Promise<string> {
   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,
-    });
+    let response = await fetchKimiUsage(token, controller.signal);
+    if (response.status === 401) {
+      const refreshed = await refreshKimiAuthToken(token);
+      if (refreshed) response = await fetchKimiUsage(refreshed, controller.signal);
+    }
     if (!response.ok) return `Usage: fetch failed (${response.status})`;
     return parseUsageSummary(await response.json());
   } catch (error) {
@@ -212,7 +250,7 @@ async function fetchKimiUsageSummary(): Promise<string> {
 }
 
 function moonshotStatus(config: KimiCodeConfig): string {
-  return MOONSHOT_TOOL_NAMES.map((toolName) => {
+  return KIMI_TOOL_NAMES.map((toolName) => {
     const tool = config.tools[toolName];
     const enabled = tool.enabled ? "enabled" : "disabled";
     const collapsed = tool.default_collapsed ? "collapsed" : "expanded";
@@ -220,8 +258,9 @@ function moonshotStatus(config: KimiCodeConfig): string {
   }).join("\n");
 }
 
-function toggleEnabled(config: KimiCodeConfig, toolName: MoonshotToolName): KimiCodeConfig {
+function toggleEnabled(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
   return {
+    ...config,
     tools: {
       ...config.tools,
       [toolName]: {
@@ -232,8 +271,9 @@ function toggleEnabled(config: KimiCodeConfig, toolName: MoonshotToolName): Kimi
   };
 }
 
-function toggleCollapsed(config: KimiCodeConfig, toolName: MoonshotToolName): KimiCodeConfig {
+function toggleCollapsed(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
   return {
+    ...config,
     tools: {
       ...config.tools,
       [toolName]: {
@@ -244,13 +284,34 @@ function toggleCollapsed(config: KimiCodeConfig, toolName: MoonshotToolName): Ki
   };
 }
 
-async function runKimiCommand(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<void> {
-  let config = loadKimiCodeConfig({ cwd: ctx.cwd, home: os.homedir() });
-  let usage = await fetchKimiUsageSummary();
+function setProtocol(config: KimiCodeConfig, protocol: KimiCodeConfig["protocol"]): KimiCodeConfig {
+  return { ...config, protocol };
+}
+
+function setUploadThreshold(config: KimiCodeConfig, thresholdBytes: number): KimiCodeConfig {
+  return { ...config, uploads: { ...config.uploads, thresholdBytes } };
+}
+
+async function refreshModelExtras(state: KimiRuntimeState): Promise<void> {
+  const token = getKimiUsageToken();
+  if (!token) return;
+  const extras = await discoverKimiModelMetadata(token, state.config.protocol);
+  if (Object.keys(extras).length > 0) {
+    Object.assign(state.modelExtras, extras);
+  }
+}
+
+async function runKimiCommand(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  state: KimiRuntimeState,
+): Promise<void> {
+  let config = applyEffectiveKimiRuntimeConfig(pi, state, ctx.cwd, { updateActiveTools: true });
+  let [usage] = await Promise.all([fetchKimiUsageSummary(), refreshModelExtras(state)]);
   ctx.ui.notify(usage);
 
   while (true) {
-    const choice = await ctx.ui.select(buildKimiMainTitle(config, ctx.cwd), [
+    const choice = await ctx.ui.select(buildKimiMainTitle(config, ctx.cwd, state.modelExtras), [
       `Edit project config (${relative(ctx.cwd, getProjectKimiCodeConfigPath(ctx.cwd))})`,
       `Edit home config (${homeRelative(getGlobalKimiCodeConfigPath(os.homedir()))})`,
       "Refresh usage",
@@ -264,9 +325,9 @@ async function runKimiCommand(pi: ExtensionAPI, ctx: ExtensionCommandContext): P
       continue;
     }
     if (choice.startsWith("Edit project config")) {
-      config = await editConfigScope(pi, ctx, "project");
+      config = await editConfigScope(pi, ctx, state, "project");
     } else if (choice.startsWith("Edit home config")) {
-      config = await editConfigScope(pi, ctx, "home");
+      config = await editConfigScope(pi, ctx, state, "home");
     }
   }
 }
@@ -274,32 +335,78 @@ async function runKimiCommand(pi: ExtensionAPI, ctx: ExtensionCommandContext): P
 async function editConfigScope(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
+  state: KimiRuntimeState,
   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",
-    ]);
+    const items = KIMI_TOOL_NAMES.map((name) => toolMenuItem(current, name));
+    items.push(protocolMenuItem(current), uploadThresholdMenuItem(current), "Back");
+    const choice = await ctx.ui.select(buildConfigScopeTitle(scope, current, ctx.cwd), items);
     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");
+    const toolName = KIMI_TOOL_NAMES.find((name) => choice.startsWith(name));
+    if (toolName) {
+      current = await editMoonshotTool(pi, ctx, state, scope, current, toolName);
+    } else if (choice.startsWith("Protocol")) {
+      current = await editProtocol(pi, ctx, state, scope, current);
+    } else if (choice.startsWith("Upload threshold")) {
+      current = await editUploadThreshold(pi, ctx, state, scope, current);
     }
   }
 }
 
+async function editProtocol(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  state: KimiRuntimeState,
+  scope: KimiConfigScope,
+  config: KimiCodeConfig,
+): Promise<KimiCodeConfig> {
+  const choice = await ctx.ui.select(`Edit protocol\n\n${formatProtocolStatus(config)}`, [
+    "Use openai protocol",
+    "Use anthropic protocol",
+    "Back",
+  ]);
+  if (!choice || choice === "Back") return config;
+  const protocol = choice.includes("anthropic") ? "anthropic" : "openai";
+  const current = setProtocol(config, protocol);
+  saveAndApplyKimiCodeConfig(pi, ctx, state, scope, current);
+  ctx.ui.notify("Saved protocol config", "info");
+  return current;
+}
+
+async function editUploadThreshold(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  state: KimiRuntimeState,
+  scope: KimiConfigScope,
+  config: KimiCodeConfig,
+): Promise<KimiCodeConfig> {
+  const input = await ctx.ui.input(
+    "Edit upload threshold\n\nExamples: 512 KiB, 2 MiB, 1.5 MB. Plain numbers are MiB.",
+    formatByteSize(config.uploads.thresholdBytes),
+  );
+  if (input === undefined) return config;
+  const thresholdBytes = parseByteSizeInput(input);
+  if (thresholdBytes === undefined || thresholdBytes <= 0) {
+    ctx.ui.notify("Upload threshold must be a positive size, for example 2 MiB", "error");
+    return config;
+  }
+  const current = setUploadThreshold(config, thresholdBytes);
+  saveAndApplyKimiCodeConfig(pi, ctx, state, scope, current);
+  ctx.ui.notify("Saved upload threshold config", "info");
+  return current;
+}
+
 async function editMoonshotTool(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
+  state: KimiRuntimeState,
   scope: KimiConfigScope,
   config: KimiCodeConfig,
-  toolName: MoonshotToolName,
+  toolName: KimiToolName,
 ): Promise<KimiCodeConfig> {
   let current = config;
   while (true) {
@@ -318,13 +425,23 @@ async function editMoonshotTool(
     } 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 });
+    saveAndApplyKimiCodeConfig(pi, ctx, state, scope, current);
     ctx.ui.notify(`Saved ${toolName} config`, "info");
+    return current;
   }
 }
 
+function saveAndApplyKimiCodeConfig(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  state: KimiRuntimeState,
+  scope: KimiConfigScope,
+  config: KimiCodeConfig,
+): void {
+  saveScopeKimiCodeConfig(scope, ctx.cwd, config);
+  applyEffectiveKimiRuntimeConfig(pi, state, ctx.cwd, { updateActiveTools: true });
+}
+
 function loadScopeKimiCodeConfig(scope: KimiConfigScope, cwd: string): KimiCodeConfig {
   if (scope === "project") return loadProjectKimiCodeConfig(cwd);
   return loadHomeKimiCodeConfig(os.homedir());
@@ -342,8 +459,22 @@ function saveScopeKimiCodeConfig(
   }
 }
 
-function buildKimiMainTitle(_config: KimiCodeConfig, _cwd: string): string {
-  return "Kimi settings";
+function buildKimiMainTitle(config: KimiCodeConfig, cwd: string, extras: KimiOAuthExtras): string {
+  const sources = loadKimiCodeConfigSources({ cwd, home: os.homedir() });
+  const modelName = extras.modelDisplay || "kimi-for-coding";
+  return [
+    `Kimi settings (provider v${KIMI_CODE_VERSION})`,
+    "",
+    `Model: ${modelName}`,
+    `Protocol: ${config.protocol} (${sources.protocol})`,
+    `Upload threshold: ${formatByteSize(config.uploads.thresholdBytes)} (${sources.uploads.thresholdBytes})`,
+    "",
+    "Effective tools:",
+    ...KIMI_TOOL_NAMES.map((toolName) => {
+      const enabled = config.tools[toolName].enabled ? "enabled" : "disabled";
+      return `- ${toolName}: ${enabled} (${sources.tools[toolName].enabled})`;
+    }),
+  ].join("\n");
 }
 
 function buildConfigScopeTitle(
@@ -355,7 +486,15 @@ function buildConfigScopeTitle(
     scope === "project"
       ? relative(cwd, getProjectKimiCodeConfigPath(cwd))
       : homeRelative(getGlobalKimiCodeConfigPath(os.homedir()));
-  return [`Edit ${scope} config`, `File: ${path}`, "", moonshotStatus(config)].join("\n");
+  return [
+    `Edit ${scope} config`,
+    `File: ${path}`,
+    "",
+    formatProtocolStatus(config),
+    formatUploadThresholdStatus(config),
+    "",
+    moonshotStatus(config),
+  ].join("\n");
 }
 
 function homeRelative(filePath: string): string {
@@ -363,66 +502,127 @@ function homeRelative(filePath: string): string {
   return filePath.startsWith(`${home}/`) ? `~/${filePath.slice(home.length + 1)}` : filePath;
 }
 
-function toolMenuItem(config: KimiCodeConfig, toolName: MoonshotToolName): string {
+function toolMenuItem(config: KimiCodeConfig, toolName: KimiToolName): string {
   return `${toolName} -> ${formatToolStatus(config, toolName)}`;
 }
 
-function formatToolStatus(config: KimiCodeConfig, toolName: MoonshotToolName): string {
+function protocolMenuItem(config: KimiCodeConfig): string {
+  return `Protocol -> ${config.protocol}`;
+}
+
+function uploadThresholdMenuItem(config: KimiCodeConfig): string {
+  return `Upload threshold -> ${formatByteSize(config.uploads.thresholdBytes)}`;
+}
+
+function formatByteSize(bytes: number): string {
+  const units = [
+    { suffix: "GiB", size: 1024 ** 3 },
+    { suffix: "MiB", size: 1024 ** 2 },
+    { suffix: "KiB", size: 1024 },
+  ];
+  for (const unit of units) {
+    if (bytes >= unit.size && bytes % unit.size === 0) {
+      return `${bytes / unit.size} ${unit.suffix}`;
+    }
+  }
+  for (const unit of units) {
+    if (bytes >= unit.size) {
+      return `${(bytes / unit.size).toFixed(2).replace(/\.00$/, "")} ${unit.suffix}`;
+    }
+  }
+  return `${bytes} B`;
+}
+
+function parseByteSizeInput(input: string): number | undefined {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(b|bytes?|kib|kb|mib|mb|gib|gb)?$/i);
+  if (!match) return undefined;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+  const unit = (match[2] ?? "mib").toLowerCase();
+  const multipliers: Record<string, number> = {
+    b: 1,
+    byte: 1,
+    bytes: 1,
+    kib: 1024,
+    kb: 1000,
+    mib: 1024 ** 2,
+    mb: 1000 ** 2,
+    gib: 1024 ** 3,
+    gb: 1000 ** 3,
+  };
+  const multiplier = multipliers[unit];
+  if (!multiplier) return undefined;
+  const bytes = Math.round(value * multiplier);
+  return Number.isSafeInteger(bytes) && bytes > 0 ? bytes : undefined;
+}
+
+function formatProtocolStatus(config: KimiCodeConfig): string {
+  return `protocol: ${config.protocol}`;
+}
+
+function formatUploadThresholdStatus(config: KimiCodeConfig): string {
+  return `upload threshold: ${formatByteSize(config.uploads.thresholdBytes)}`;
+}
+
+function formatToolStatus(config: KimiCodeConfig, toolName: KimiToolName): 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) {
-  const config = loadKimiCodeConfig({ cwd: process.cwd(), home: os.homedir() });
-
-  pi.registerProvider(PROVIDER_ID, {
-    baseUrl: getBaseUrl(),
-    apiKey: "KIMI_API_KEY",
-    api: KIMI_API_TYPE,
-    streamSimple: streamSimpleKimi,
-
-    headers: getCommonHeaders(),
-
-    models: [
-      applyKimiEnvOverridesToModel({
-        id: "kimi-for-coding",
-        name: "Kimi for Coding",
-        reasoning: true,
-        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: {
-      name: "Kimi Code (OAuth)",
-      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));
-        });
+export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
+  return async (pi: ExtensionAPI) => {
+    const cwd = process.cwd();
+    const config = loadKimiCodeConfig({ cwd, home: os.homedir() }, overrides);
+    const baseModel = buildKimiModelFromConfig(config.model);
+    const discoveryToken = getKimiUsageToken();
+    const discovered = discoveryToken
+      ? await discoverKimiModelMetadata(discoveryToken, config.protocol)
+      : {};
+    const state: KimiRuntimeState = { cwd, config, modelExtras: discovered, overrides };
+    reloadEffectiveKimiRuntimeConfig(state, cwd);
+    const model = applyKimiOAuthExtrasToModel(baseModel, discovered);
+
+    pi.registerProvider(PROVIDER_ID, {
+      baseUrl: getBaseUrl(config.protocol),
+      apiKey: "$KIMI_API_KEY",
+      api: getKimiApiType(config.protocol),
+      streamSimple: streamSimpleKimi,
+
+      models: [model],
+
+      oauth: {
+        name: "Kimi Code (OAuth)",
+        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;
+          state.modelExtras = extras;
+          reloadEffectiveKimiRuntimeConfig(state, state.cwd);
+          return models.map((model) => {
+            if (model.id !== "kimi-for-coding") return model;
+            return applyKimiOAuthExtrasToModel(model, extras);
+          });
+        },
       },
-    },
-  });
+    });
 
-  registerConfiguredMoonshotTools(pi, config, { updateActiveTools: false });
+    registerConfiguredMoonshotTools(pi, state.config, { updateActiveTools: false });
 
-  pi.registerCommand("kimi-settings", {
-    description: "Show Kimi usage and configure optional Kimi tools",
-    handler: async (_args, ctx) => {
-      await runKimiCommand(pi, ctx);
-    },
-  });
+    pi.registerCommand("kimi-settings", {
+      description: "Show Kimi usage and configure optional Kimi tools",
+      handler: async (_args, ctx) => {
+        await runKimiCommand(pi, ctx, state);
+      },
+    });
+  };
 }
+
+export default KimiCode();

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
   "keywords": [
     "ai-provider",
     "coding-agent",
-    "device-code",
     "kimi",
-    "kimi-coder",
+    "kimi-code",
     "kimi-for-coding",
     "kimi-k2",
     "kimi-k2.5",
     "kimi-k2.6",
+    "kimi-k2.7",
     "llm",
     "llm-provider",
     "moonshot",
@@ -20,10 +20,8 @@
     "pi",
     "pi-coding-agent",
     "pi-extension",
-    "pi-mono",
     "pi-package",
-    "pi-provider",
-    "subscription"
+    "pi-provider"
   ],
   "bugs": {
     "url": "https://github.com/Leechael/pi-provider-kimi-code/issues"
@@ -54,7 +52,8 @@
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.78.0",
     "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@j178/prek": "^0.3.8",
+    "@earendil-works/pi-tui": "^0.78.1",
+    "@j178/prek": "^0.4.4",
     "@types/node": "^24.0.0",
     "oxfmt": "^0.44.0",
     "oxlint": "^1.59.0",
@@ -62,7 +61,8 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "pi": {
     "extensions": [