pi-provider-kimi-code 0.6.0 → 0.6.1

package/README.md

@@ -5,9 +5,9 @@
 
 **Use Kimi Code in Pi, with the Kimi parts handled.**
 
-Pi already has a basic `kimi-coding` provider. This extension is for the parts that start to matter once Kimi Code becomes part of your real Pi workflow: account login reuse, file uploads, measured cache behavior, live model metadata, and optional Moonshot search/fetch/datasource tools.
+Pi already has a basic `kimi-coding` provider. This extension is for the parts that start to matter once Kimi Code becomes part of your real Pi workflow: account login reuse, file uploads, tool schema compatibility, live model metadata, measured cache behavior, and API-tested parameter handling.
 
-> **Kimi K2.7 supported.** The provider automatically discovers the current model from Kimi's `/v1/models` endpoint at login time, so new rollouts (including K2.7) are picked up immediately without a package update.
+> **Kimi K2.7 supported.** The provider automatically discovers the current model from Kimi's `/v1/models` endpoint at login, refresh, and `/kimi-settings` time, so new rollouts (including K2.7) are picked up immediately without a package update.
 
 ## Why this exists
 
@@ -18,19 +18,24 @@ Kimi's API surface goes beyond the LLM itself. It includes file uploads, web sea
 - **Use your Kimi account.** Log in with `/login kimi-coding`, or reuse an existing `kimi-code` session.
 - **Send files the Kimi way.** Large inline images go through Kimi's Files API and become `ms://` references instead of huge base64 payloads.
 - **Know what the cache is doing.** Kimi caches by content prefix. This repo measures that behavior instead of pretending `prompt_cache_key` controls it.
-- **Use the safer protocol by default.** OpenAI-compatible mode is the default because tool results are less ambiguous there. Anthropic-compatible mode is still available.
+- **Keep Pi's tools working.** Moonshot's API rejects tool schemas over 15 KB — a limit that Pi's extension ecosystem regularly hits ([#16](https://github.com/Leechael/pi-provider-kimi-code/issues/16), [#21](https://github.com/Leechael/pi-provider-kimi-code/issues/21)). This extension automatically deduplicates schemas with `$ref`/`$defs` before sending, so subagents and other extensions don't break.
+- **Tested against the live API.** Thinking config, parameter constraints, protocol compatibility, and streaming behavior are all verified against Kimi's Coding endpoint — not assumed from docs. When the API rejects something (wrong `temperature`, unsupported `tool_choice`), the provider strips it before you see a 400.
 - **Turn on Kimi-native tools when you want them.** `moonshot_search`, `moonshot_fetch`, and `kimi_datasource` are opt-in, configurable per user or per project.
+- **Embed in your own build.** `KimiCode()` factory lets you ship Kimi Code support inside a custom Pi agent with programmatic config overrides — no file-based extension path needed.
 
 ## What this package adds
 
 - Kimi account login in Pi, plus `KIMI_API_KEY` for CI or pay-per-token use.
 - `kimi-code` credential reuse from `~/.kimi/credentials/kimi-code.json`.
 - Kimi Files API uploads for large inline images.
-- Live model metadata from Kimi at login / refresh time.
+- Live model metadata from Kimi at login, refresh, and `/kimi-settings` time.
 - OpenAI-compatible mode by default, Anthropic-compatible mode on request.
-- Kimi K2.6 reasoning level mapping for Pi's reasoning controls.
+- Kimi K2.7 reasoning level mapping for Pi's reasoning controls.
+- Tool schema dedup to stay under Moonshot's 15 KB per-tool-schema limit.
+- K2.7 parameter guard: strips `temperature`, `top_p`, and `tool_choice` values that the API rejects.
 - Stream cleanup for Kimi's thinking-only placeholder text.
 - Optional `moonshot_search`, `moonshot_fetch`, and unified datasource `kimi_datasource` tools via `/kimi-settings`.
+- Programmatic `KimiCode()` factory for embedding in custom Pi builds.
 - No build step; Pi loads the TypeScript extension directly.
 
 ## Install
@@ -56,6 +61,21 @@ curl -L https://github.com/Leechael/pi-provider-kimi-code/releases/latest/downlo
 pi install /tmp/pi-provider-kimi-code
 ```
 
+### Programmatic usage
+
+Use `KimiCode()` to embed Kimi Code as a provider inside a custom Pi build:
+
+```typescript
+import { main } from "@earendil-works/pi-coding-agent";
+import { KimiCode } from "pi-provider-kimi-code";
+
+main(process.argv.slice(2), {
+  extensionFactories: [KimiCode({ protocol: "anthropic" })],
+});
+```
+
+`KimiCode()` with no arguments behaves identically to the file-based extension. Pass a `KimiCodeConfigPatch` to override defaults (protocol, upload threshold, tools, model parameters). See [docs/programmatic-usage.md](docs/programmatic-usage.md) for the full API.
+
 ## Sign in
 
 Inside Pi, run:
@@ -103,7 +123,7 @@ Fallback values:
 - Input: text and image
 - Reasoning: enabled
 
-The provider maps Pi's reasoning levels to Kimi's reasoning-effort controls. The exact mapping depends on the model returned by the server at login time, and the provider refreshes it automatically on every credential refresh.
+The provider maps Pi's reasoning levels to Kimi's `reasoning_effort` and top-level `thinking` parameters. The mapping refreshes automatically on credential refresh. Opening `/kimi-settings` also re-discovers the latest model metadata.
 
 ## Optional tools
 
@@ -115,7 +135,9 @@ Inside Pi, run:
 /kimi-settings
 ```
 
-That command shows your current Kimi usage summary and lets you edit the home or project config. Changes apply to the active session tool set.
+That command shows the current server-side model name (e.g. "K2.7 Code High Speed"), your Kimi usage summary, and lets you edit the home or project config. Changes apply to the active session tool set.
+
+Configurable settings include protocol mode, upload threshold, and per-tool enable/collapse.
 
 Config files are JSON:
 
@@ -136,6 +158,8 @@ Project config overrides home config with a deep merge. Missing files or missing
 
 ```json
 {
+  "protocol": "openai",
+  "uploads": { "thresholdBytes": 1048576 },
   "tools": {
     "moonshot_search": { "enabled": true, "default_collapsed": true },
     "moonshot_fetch": { "enabled": true, "default_collapsed": true },
@@ -176,9 +200,9 @@ If you already use another search or fetch tool, pick one path for a session. Ov
 Most users do not need environment variables. Two are worth knowing:
 
 - `KIMI_API_KEY` — static API key for CI or pay-per-token use.
-- `KIMI_CODE_PROTOCOL` — `openai` by default; set to `anthropic` if your Pi setup needs Anthropic-compatible requests.
+- `KIMI_CODE_PROTOCOL` — `openai` by default; set to `anthropic` if your Pi setup needs Anthropic-compatible requests. Can also be set through `/kimi-settings` or JSON config.
 
-Moonshot search/fetch tools are configured through `/kimi-settings` or JSON config files, not env vars.
+Tools, protocol, and upload threshold are all configurable through `/kimi-settings` or JSON config files.
 
 The full env list, including base URL overrides, `kimi-code` path overrides, upload tuning, debug logs, and model metadata overrides, lives in [docs/ENV.md](docs/ENV.md).
 
@@ -263,6 +287,7 @@ In OpenAI mode this extension maps the `developer` role to `system` (Kimi's Codi
 
 - Pi: [earendil-works/pi](https://github.com/earendil-works/pi)
 - Environment variables: [docs/ENV.md](docs/ENV.md)
+- Programmatic usage: [docs/programmatic-usage.md](docs/programmatic-usage.md)
 - Testing guide: [docs/TESTING.md](docs/TESTING.md)
 - Cache behavior: [docs/caching.md](docs/caching.md)
 - Architecture notes: [docs/architecture.md](docs/architecture.md)

package/index.ts

@@ -18,17 +18,18 @@
  *   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,
@@ -40,20 +41,18 @@ import {
   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, refreshKimiAuthToken, refreshKimiCodeToken } from "./src/oauth.ts";
-import { streamSimpleKimi } from "./src/stream.ts";
+import { setStoreResolvedKimiConfig, streamSimpleKimi } from "./src/stream.ts";
 import { buildMoonshotFetchTool, buildMoonshotSearchTool } from "./src/tools/moonshot.ts";
 import { buildKimiDatasourceTool } from "./src/tools/datasource.ts";
 type KimiConfigScope = "project" | "home";
@@ -72,6 +71,13 @@ 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);
@@ -105,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;
@@ -231,6 +260,7 @@ function moonshotStatus(config: KimiCodeConfig): string {
 
 function toggleEnabled(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
   return {
+    ...config,
     tools: {
       ...config.tools,
       [toolName]: {
@@ -243,6 +273,7 @@ function toggleEnabled(config: KimiCodeConfig, toolName: KimiToolName): KimiCode
 
 function toggleCollapsed(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
   return {
+    ...config,
     tools: {
       ...config.tools,
       [toolName]: {
@@ -253,13 +284,34 @@ function toggleCollapsed(config: KimiCodeConfig, toolName: KimiToolName): KimiCo
   };
 }
 
-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",
@@ -273,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");
     }
   }
 }
@@ -283,26 +335,75 @@ 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 items = KIMI_TOOL_NAMES.map((name) => toolMenuItem(current, name));
-    items.push("Back");
+    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() });
     }
     const toolName = KIMI_TOOL_NAMES.find((name) => choice.startsWith(name));
     if (toolName) {
-      current = await editMoonshotTool(pi, ctx, scope, current, 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: KimiToolName,
@@ -324,14 +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());
@@ -349,10 +459,15 @@ function saveScopeKimiCodeConfig(
   }
 }
 
-function buildKimiMainTitle(config: KimiCodeConfig, cwd: string): string {
+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",
+    `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) => {
@@ -371,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 {
@@ -383,6 +506,64 @@ function toolMenuItem(config: KimiCodeConfig, toolName: KimiToolName): string {
   return `${toolName} -> ${formatToolStatus(config, toolName)}`;
 }
 
+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";
@@ -390,53 +571,58 @@ function formatToolStatus(config: KimiCodeConfig, toolName: KimiToolName): strin
   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,
-
-    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,6 +1,6 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
   "keywords": [
     "ai-provider",