Auth: switch Kimi Coding to built-in provider

docs/concepts/model-providers.md

@@ -158,30 +158,19 @@ Moonshot uses OpenAI-compatible endpoints, so configure it as a custom provider:
 }
 ```
 
-### Kimi Code
+### Kimi Coding
 
-Kimi Code uses a dedicated endpoint and key (separate from Moonshot):
+Kimi Coding uses Moonshot AI's Anthropic-compatible endpoint:
 
-- Provider: `kimi-code`
+- Provider: `kimi-coding`
-- Auth: `KIMICODE_API_KEY`
+- Auth: `KIMI_API_KEY`
-- Example model: `kimi-code/kimi-for-coding`
+- Example model: `kimi-coding/k2p5`
 
 ```json5
 {
-  env: { KIMICODE_API_KEY: "sk-..." },
+  env: { KIMI_API_KEY: "sk-..." },
   agents: {
-    defaults: { model: { primary: "kimi-code/kimi-for-coding" } }
+    defaults: { model: { primary: "kimi-coding/k2p5" } }
-  },
-  models: {
-    mode: "merge",
-    providers: {
-      "kimi-code": {
-        baseUrl: "https://api.kimi.com/coding/v1",
-        apiKey: "${KIMICODE_API_KEY}",
-        api: "openai-completions",
-        models: [{ id: "kimi-for-coding", name: "Kimi For Coding" }]
-      }
-    }
   }
 }
 ```

docs/gateway/configuration.md

@@ -2429,48 +2429,25 @@ Notes:
 - Model ref: `moonshot/kimi-k2.5`.
 - Use `https://api.moonshot.cn/v1` if you need the China endpoint.
 
-### Kimi Code
+### Kimi Coding
 
-Use Kimi Code's dedicated OpenAI-compatible endpoint (separate from Moonshot):
+Use Moonshot AI's Kimi Coding endpoint (Anthropic-compatible, built-in provider):
 
 ```json5
 {
-  env: { KIMICODE_API_KEY: "sk-..." },
+  env: { KIMI_API_KEY: "sk-..." },
   agents: {
     defaults: {
-      model: { primary: "kimi-code/kimi-for-coding" },
+      model: { primary: "kimi-coding/k2p5" },
-      models: { "kimi-code/kimi-for-coding": { alias: "Kimi Code" } }
+      models: { "kimi-coding/k2p5": { alias: "Kimi K2.5" } }
-    }
-  },
-  models: {
-    mode: "merge",
-    providers: {
-      "kimi-code": {
-        baseUrl: "https://api.kimi.com/coding/v1",
-        apiKey: "${KIMICODE_API_KEY}",
-        api: "openai-completions",
-        models: [
-          {
-            id: "kimi-for-coding",
-            name: "Kimi For Coding",
-            reasoning: true,
-            input: ["text"],
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-            contextWindow: 262144,
-            maxTokens: 32768,
-            headers: { "User-Agent": "KimiCLI/0.77" },
-            compat: { supportsDeveloperRole: false }
-          }
-        ]
-      }
     }
   }
 }
 ```
 
 Notes:
-- Set `KIMICODE_API_KEY` in the environment or use `openclaw onboard --auth-choice kimi-code-api-key`.
+- Set `KIMI_API_KEY` in the environment or use `openclaw onboard --auth-choice kimi-code-api-key`.
-- Model ref: `kimi-code/kimi-for-coding`.
+- Model ref: `kimi-coding/k2p5`.
 
 ### Synthetic (Anthropic-compatible)
 

docs/providers/index.md

@@ -38,7 +38,7 @@ See [Venice AI](/providers/venice).
 - [Qwen (OAuth)](/providers/qwen)
 - [OpenRouter](/providers/openrouter)
 - [Vercel AI Gateway](/providers/vercel-ai-gateway)
-- [Moonshot AI (Kimi + Kimi Code)](/providers/moonshot)
+- [Moonshot AI (Kimi + Kimi Coding)](/providers/moonshot)
 - [OpenCode Zen](/providers/opencode)
 - [Amazon Bedrock](/bedrock)
 - [Z.AI](/providers/zai)

docs/providers/models.md

@@ -35,7 +35,7 @@ See [Venice AI](/providers/venice).
 - [Anthropic (API + Claude Code CLI)](/providers/anthropic)
 - [OpenRouter](/providers/openrouter)
 - [Vercel AI Gateway](/providers/vercel-ai-gateway)
-- [Moonshot AI (Kimi + Kimi Code)](/providers/moonshot)
+- [Moonshot AI (Kimi + Kimi Coding)](/providers/moonshot)
 - [Synthetic](/providers/synthetic)
 - [OpenCode Zen](/providers/opencode)
 - [Z.AI](/providers/zai)

docs/providers/moonshot.md

@@ -1,7 +1,7 @@
 ---
-summary: "Configure Moonshot K2 vs Kimi Code (separate providers + keys)"
+summary: "Configure Moonshot K2 vs Kimi Coding (separate providers + keys)"
 read_when:
-  - You want Moonshot K2 (Moonshot Open Platform) vs Kimi Code setup
+  - You want Moonshot K2 (Moonshot Open Platform) vs Kimi Coding setup
   - You need to understand separate endpoints, keys, and model refs
   - You want copy/paste config for either provider
 ---
@@ -10,7 +10,7 @@ read_when:
 
 Moonshot provides the Kimi API with OpenAI-compatible endpoints. Configure the
 provider and set the default model to `moonshot/kimi-k2.5`, or use
-Kimi Code with `kimi-code/kimi-for-coding`.
+Kimi Coding with `kimi-coding/k2p5`.
 
 Current Kimi K2 model IDs:
 {/* moonshot-kimi-k2-ids:start */}
@@ -25,13 +25,13 @@ Current Kimi K2 model IDs:
 openclaw onboard --auth-choice moonshot-api-key
 ```
 
-Kimi Code:
+Kimi Coding:
 
 ```bash
 openclaw onboard --auth-choice kimi-code-api-key
 ```
 
-Note: Moonshot and Kimi Code are separate providers. Keys are not interchangeable, endpoints differ, and model refs differ (Moonshot uses `moonshot/...`, Kimi Code uses `kimi-code/...`).
+Note: Moonshot and Kimi Coding are separate providers. Keys are not interchangeable, endpoints differ, and model refs differ (Moonshot uses `moonshot/...`, Kimi Coding uses `kimi-coding/...`).
 
 ## Config snippet (Moonshot API)
 
@@ -114,39 +114,16 @@ Note: Moonshot and Kimi Code are separate providers. Keys are not interchangeabl
 }
 ```
 
-## Kimi Code
+## Kimi Coding
 
 ```json5
 {
-  env: { KIMICODE_API_KEY: "sk-..." },
+  env: { KIMI_API_KEY: "sk-..." },
   agents: {
     defaults: {
-      model: { primary: "kimi-code/kimi-for-coding" },
+      model: { primary: "kimi-coding/k2p5" },
       models: {
-        "kimi-code/kimi-for-coding": { alias: "Kimi Code" }
+        "kimi-coding/k2p5": { alias: "Kimi K2.5" }
-      }
-    }
-  },
-  models: {
-    mode: "merge",
-    providers: {
-      "kimi-code": {
-        baseUrl: "https://api.kimi.com/coding/v1",
-        apiKey: "${KIMICODE_API_KEY}",
-        api: "openai-completions",
-        models: [
-          {
-            id: "kimi-for-coding",
-            name: "Kimi For Coding",
-            reasoning: true,
-            input: ["text"],
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-            contextWindow: 262144,
-            maxTokens: 32768,
-            headers: { "User-Agent": "KimiCLI/0.77" },
-            compat: { supportsDeveloperRole: false }
-          }
-        ]
       }
     }
   }
@@ -155,7 +132,7 @@ Note: Moonshot and Kimi Code are separate providers. Keys are not interchangeabl
 
 ## Notes
 
-- Moonshot model refs use `moonshot/<modelId>`. Kimi Code model refs use `kimi-code/<modelId>`.
+- Moonshot model refs use `moonshot/<modelId>`. Kimi Coding model refs use `kimi-coding/<modelId>`. 
 - Override pricing and context metadata in `models.providers` if needed.
 - If Moonshot publishes different context limits for a model, adjust
   `contextWindow` accordingly.

docs/start/wizard.md

@@ -97,8 +97,8 @@ Tip: `--json` does **not** imply non-interactive mode. Use `--non-interactive` (
    - **Synthetic (Anthropic-compatible)**: prompts for `SYNTHETIC_API_KEY`.
    - More detail: [Synthetic](/providers/synthetic)
    - **Moonshot (Kimi K2)**: config is auto-written.
-   - **Kimi Code**: config is auto-written.
+   - **Kimi Coding**: config is auto-written.
-   - More detail: [Moonshot AI (Kimi + Kimi Code)](/providers/moonshot)
+   - More detail: [Moonshot AI (Kimi + Kimi Coding)](/providers/moonshot)
    - **Skip**: no auth configured yet.
    - Pick a default model from detected options (or enter provider/model manually).
    - Wizard runs a model check and warns if the configured model is unknown or missing auth.

src/agents/model-auth.ts

@@ -269,6 +269,10 @@ export function resolveEnvApiKey(provider: string): EnvApiKeyResult | null {
     return pick("QWEN_OAUTH_TOKEN") ?? pick("QWEN_PORTAL_API_KEY");
   }
 
+  if (normalized === "kimi-coding") {
+    return pick("KIMI_API_KEY") ?? pick("KIMICODE_API_KEY");
+  }
+
   const envMap: Record<string, string> = {
     openai: "OPENAI_API_KEY",
     google: "GEMINI_API_KEY",
@@ -279,7 +283,6 @@ export function resolveEnvApiKey(provider: string): EnvApiKeyResult | null {
     openrouter: "OPENROUTER_API_KEY",
     "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
     moonshot: "MOONSHOT_API_KEY",
-    "kimi-code": "KIMICODE_API_KEY",
     minimax: "MINIMAX_API_KEY",
     xiaomi: "XIAOMI_API_KEY",
     synthetic: "SYNTHETIC_API_KEY",

src/agents/model-selection.test.ts

@@ -17,6 +17,7 @@ describe("model-selection", () => {
       expect(normalizeProviderId("z-ai")).toBe("zai");
       expect(normalizeProviderId("OpenCode-Zen")).toBe("opencode");
       expect(normalizeProviderId("qwen")).toBe("qwen-portal");
+      expect(normalizeProviderId("kimi-code")).toBe("kimi-coding");
     });
   });
 

src/agents/model-selection.ts

@@ -29,6 +29,7 @@ export function normalizeProviderId(provider: string): string {
   if (normalized === "z.ai" || normalized === "z-ai") return "zai";
   if (normalized === "opencode-zen") return "opencode";
   if (normalized === "qwen") return "qwen-portal";
+  if (normalized === "kimi-code") return "kimi-coding";
   return normalized;
 }
 

src/agents/models-config.providers.ts

@@ -51,18 +51,6 @@ const MOONSHOT_DEFAULT_COST = {
   cacheRead: 0,
   cacheWrite: 0,
 };
-const KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
-const KIMI_CODE_MODEL_ID = "kimi-for-coding";
-const KIMI_CODE_CONTEXT_WINDOW = 262144;
-const KIMI_CODE_MAX_TOKENS = 32768;
-const KIMI_CODE_HEADERS = { "User-Agent": "KimiCLI/0.77" } as const;
-const KIMI_CODE_COMPAT = { supportsDeveloperRole: false } as const;
-const KIMI_CODE_DEFAULT_COST = {
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-};
 
 const QWEN_PORTAL_BASE_URL = "https://portal.qwen.ai/v1";
 const QWEN_PORTAL_OAUTH_PLACEHOLDER = "qwen-oauth";
@@ -297,26 +285,6 @@ function buildMoonshotProvider(): ProviderConfig {
   };
 }
 
-function buildKimiCodeProvider(): ProviderConfig {
-  return {
-    baseUrl: KIMI_CODE_BASE_URL,
-    api: "openai-completions",
-    models: [
-      {
-        id: KIMI_CODE_MODEL_ID,
-        name: "Kimi For Coding",
-        reasoning: true,
-        input: ["text"],
-        cost: KIMI_CODE_DEFAULT_COST,
-        contextWindow: KIMI_CODE_CONTEXT_WINDOW,
-        maxTokens: KIMI_CODE_MAX_TOKENS,
-        headers: KIMI_CODE_HEADERS,
-        compat: KIMI_CODE_COMPAT,
-      },
-    ],
-  };
-}
-
 function buildQwenPortalProvider(): ProviderConfig {
   return {
     baseUrl: QWEN_PORTAL_BASE_URL,
@@ -410,13 +378,6 @@ export async function resolveImplicitProviders(params: {
     providers.moonshot = { ...buildMoonshotProvider(), apiKey: moonshotKey };
   }
 
-  const kimiCodeKey =
-    resolveEnvApiKeyVarName("kimi-code") ??
-    resolveApiKeyFromProfiles({ provider: "kimi-code", store: authStore });
-  if (kimiCodeKey) {
-    providers["kimi-code"] = { ...buildKimiCodeProvider(), apiKey: kimiCodeKey };
-  }
-
   const syntheticKey =
     resolveEnvApiKeyVarName("synthetic") ??
     resolveApiKeyFromProfiles({ provider: "synthetic", store: authStore });

src/agents/models-config.skips-writing-models-json-no-env-token.test.ts

@@ -48,7 +48,7 @@ describe("models-config", () => {
       const previous = process.env.COPILOT_GITHUB_TOKEN;
       const previousGh = process.env.GH_TOKEN;
       const previousGithub = process.env.GITHUB_TOKEN;
-      const previousKimiCode = process.env.KIMICODE_API_KEY;
+      const previousKimiCode = process.env.KIMI_API_KEY;
       const previousMinimax = process.env.MINIMAX_API_KEY;
       const previousMoonshot = process.env.MOONSHOT_API_KEY;
       const previousSynthetic = process.env.SYNTHETIC_API_KEY;
@@ -57,7 +57,7 @@ describe("models-config", () => {
       delete process.env.COPILOT_GITHUB_TOKEN;
       delete process.env.GH_TOKEN;
       delete process.env.GITHUB_TOKEN;
-      delete process.env.KIMICODE_API_KEY;
+      delete process.env.KIMI_API_KEY;
       delete process.env.MINIMAX_API_KEY;
       delete process.env.MOONSHOT_API_KEY;
       delete process.env.SYNTHETIC_API_KEY;
@@ -85,8 +85,8 @@ describe("models-config", () => {
         else process.env.GH_TOKEN = previousGh;
         if (previousGithub === undefined) delete process.env.GITHUB_TOKEN;
         else process.env.GITHUB_TOKEN = previousGithub;
-        if (previousKimiCode === undefined) delete process.env.KIMICODE_API_KEY;
+        if (previousKimiCode === undefined) delete process.env.KIMI_API_KEY;
-        else process.env.KIMICODE_API_KEY = previousKimiCode;
+        else process.env.KIMI_API_KEY = previousKimiCode;
         if (previousMinimax === undefined) delete process.env.MINIMAX_API_KEY;
         else process.env.MINIMAX_API_KEY = previousMinimax;
         if (previousMoonshot === undefined) delete process.env.MOONSHOT_API_KEY;

src/cli/program/register.onboard.ts

@@ -69,7 +69,7 @@ export function registerOnboardCommand(program: Command) {
     .option("--openrouter-api-key <key>", "OpenRouter API key")
     .option("--ai-gateway-api-key <key>", "Vercel AI Gateway API key")
     .option("--moonshot-api-key <key>", "Moonshot API key")
-    .option("--kimi-code-api-key <key>", "Kimi Code API key")
+    .option("--kimi-code-api-key <key>", "Kimi Coding API key")
     .option("--gemini-api-key <key>", "Gemini API key")
     .option("--zai-api-key <key>", "Z.AI API key")
     .option("--xiaomi-api-key <key>", "Xiaomi API key")

src/commands/auth-choice-options.ts

@@ -99,7 +99,7 @@ const AUTH_CHOICE_GROUP_DEFS: {
   {
     value: "moonshot",
     label: "Moonshot AI",
-    hint: "Kimi K2 + Kimi Code",
+    hint: "Kimi K2 + Kimi Coding",
     choices: ["moonshot-api-key", "kimi-code-api-key"],
   },
   {
@@ -147,7 +147,7 @@ export function buildAuthChoiceOptions(params: {
     label: "Vercel AI Gateway API key",
   });
   options.push({ value: "moonshot-api-key", label: "Moonshot AI API key" });
-  options.push({ value: "kimi-code-api-key", label: "Kimi Code API key" });
+  options.push({ value: "kimi-code-api-key", label: "Kimi Coding API key" });
   options.push({ value: "synthetic-api-key", label: "Synthetic API key" });
   options.push({
     value: "venice-api-key",

src/commands/auth-choice.apply.api-providers.ts

@@ -30,7 +30,7 @@ import {
   applyXiaomiConfig,
   applyXiaomiProviderConfig,
   applyZaiConfig,
-  KIMI_CODE_MODEL_REF,
+  KIMI_CODING_MODEL_REF,
   MOONSHOT_DEFAULT_MODEL_REF,
   OPENROUTER_DEFAULT_MODEL_REF,
   SYNTHETIC_DEFAULT_MODEL_REF,
@@ -38,7 +38,7 @@ import {
   VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF,
   XIAOMI_DEFAULT_MODEL_REF,
   setGeminiApiKey,
-  setKimiCodeApiKey,
+  setKimiCodingApiKey,
   setMoonshotApiKey,
   setOpencodeZenApiKey,
   setOpenrouterApiKey,
@@ -77,7 +77,10 @@ export async function applyAuthChoiceApiProviders(
       authChoice = "ai-gateway-api-key";
     } else if (params.opts.tokenProvider === "moonshot") {
       authChoice = "moonshot-api-key";
-    } else if (params.opts.tokenProvider === "kimi-code") {
+    } else if (
+      params.opts.tokenProvider === "kimi-code" ||
+      params.opts.tokenProvider === "kimi-coding"
+    ) {
       authChoice = "kimi-code-api-key";
     } else if (params.opts.tokenProvider === "google") {
       authChoice = "gemini-api-key";
@@ -273,51 +276,56 @@ export async function applyAuthChoiceApiProviders(
 
   if (authChoice === "kimi-code-api-key") {
     let hasCredential = false;
-    if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "kimi-code") {
+    const tokenProvider = params.opts?.tokenProvider?.trim().toLowerCase();
-      await setKimiCodeApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+    if (
+      !hasCredential &&
+      params.opts?.token &&
+      (tokenProvider === "kimi-code" || tokenProvider === "kimi-coding")
+    ) {
+      await setKimiCodingApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
       hasCredential = true;
     }
 
     if (!hasCredential) {
       await params.prompter.note(
         [
-          "Kimi Code uses a dedicated endpoint and API key.",
+          "Kimi Coding uses a dedicated endpoint and API key.",
           "Get your API key at: https://www.kimi.com/code/en",
         ].join("\n"),
-        "Kimi Code",
+        "Kimi Coding",
       );
     }
-    const envKey = resolveEnvApiKey("kimi-code");
+    const envKey = resolveEnvApiKey("kimi-coding");
     if (envKey) {
       const useExisting = await params.prompter.confirm({
-        message: `Use existing KIMICODE_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+        message: `Use existing KIMI_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
         initialValue: true,
       });
       if (useExisting) {
-        await setKimiCodeApiKey(envKey.apiKey, params.agentDir);
+        await setKimiCodingApiKey(envKey.apiKey, params.agentDir);
         hasCredential = true;
       }
     }
     if (!hasCredential) {
       const key = await params.prompter.text({
-        message: "Enter Kimi Code API key",
+        message: "Enter Kimi Coding API key",
         validate: validateApiKeyInput,
       });
-      await setKimiCodeApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+      await setKimiCodingApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
     }
     nextConfig = applyAuthProfileConfig(nextConfig, {
-      profileId: "kimi-code:default",
+      profileId: "kimi-coding:default",
-      provider: "kimi-code",
+      provider: "kimi-coding",
       mode: "api_key",
     });
     {
       const applied = await applyDefaultModelChoice({
         config: nextConfig,
         setDefaultModel: params.setDefaultModel,
-        defaultModel: KIMI_CODE_MODEL_REF,
+        defaultModel: KIMI_CODING_MODEL_REF,
         applyDefaultConfig: applyKimiCodeConfig,
         applyProviderConfig: applyKimiCodeProviderConfig,
-        noteDefault: KIMI_CODE_MODEL_REF,
+        noteDefault: KIMI_CODING_MODEL_REF,
         noteAgentModel,
         prompter: params.prompter,
       });

src/commands/auth-choice.preferred-provider.ts

@@ -13,7 +13,7 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE: Partial<Record<AuthChoice, string>> = {
   "openrouter-api-key": "openrouter",
   "ai-gateway-api-key": "vercel-ai-gateway",
   "moonshot-api-key": "moonshot",
-  "kimi-code-api-key": "kimi-code",
+  "kimi-code-api-key": "kimi-coding",
   "gemini-api-key": "google",
   "google-antigravity": "google-antigravity",
   "google-gemini-cli": "google-gemini-cli",

src/commands/onboard-auth.config-core.ts

@@ -19,11 +19,8 @@ import {
   ZAI_DEFAULT_MODEL_REF,
 } from "./onboard-auth.credentials.js";
 import {
-  buildKimiCodeModelDefinition,
   buildMoonshotModelDefinition,
-  KIMI_CODE_BASE_URL,
+  KIMI_CODING_MODEL_REF,
-  KIMI_CODE_MODEL_ID,
-  KIMI_CODE_MODEL_REF,
   MOONSHOT_BASE_URL,
   MOONSHOT_DEFAULT_MODEL_ID,
   MOONSHOT_DEFAULT_MODEL_REF,
@@ -206,29 +203,9 @@ export function applyMoonshotConfig(cfg: OpenClawConfig): OpenClawConfig {
 
 export function applyKimiCodeProviderConfig(cfg: OpenClawConfig): OpenClawConfig {
   const models = { ...cfg.agents?.defaults?.models };
-  models[KIMI_CODE_MODEL_REF] = {
+  models[KIMI_CODING_MODEL_REF] = {
-    ...models[KIMI_CODE_MODEL_REF],
+    ...models[KIMI_CODING_MODEL_REF],
-    alias: models[KIMI_CODE_MODEL_REF]?.alias ?? "Kimi Code",
+    alias: models[KIMI_CODING_MODEL_REF]?.alias ?? "Kimi K2.5",
-  };
-
-  const providers = { ...cfg.models?.providers };
-  const existingProvider = providers["kimi-code"];
-  const existingModels = Array.isArray(existingProvider?.models) ? existingProvider.models : [];
-  const defaultModel = buildKimiCodeModelDefinition();
-  const hasDefaultModel = existingModels.some((model) => model.id === KIMI_CODE_MODEL_ID);
-  const mergedModels = hasDefaultModel ? existingModels : [...existingModels, defaultModel];
-  const { apiKey: existingApiKey, ...existingProviderRest } = (existingProvider ?? {}) as Record<
-    string,
-    unknown
-  > as { apiKey?: string };
-  const resolvedApiKey = typeof existingApiKey === "string" ? existingApiKey : undefined;
-  const normalizedApiKey = resolvedApiKey?.trim();
-  providers["kimi-code"] = {
-    ...existingProviderRest,
-    baseUrl: KIMI_CODE_BASE_URL,
-    api: "openai-completions",
-    ...(normalizedApiKey ? { apiKey: normalizedApiKey } : {}),
-    models: mergedModels.length > 0 ? mergedModels : [defaultModel],
   };
 
   return {
@@ -240,10 +217,6 @@ export function applyKimiCodeProviderConfig(cfg: OpenClawConfig): OpenClawConfig
         models,
       },
     },
-    models: {
-      mode: cfg.models?.mode ?? "merge",
-      providers,
-    },
   };
 }
 
@@ -262,7 +235,7 @@ export function applyKimiCodeConfig(cfg: OpenClawConfig): OpenClawConfig {
                 fallbacks: (existingModel as { fallbacks?: string[] }).fallbacks,
               }
             : undefined),
-          primary: KIMI_CODE_MODEL_REF,
+          primary: KIMI_CODING_MODEL_REF,
         },
       },
     },

src/commands/onboard-auth.credentials.ts

@@ -74,13 +74,13 @@ export async function setMoonshotApiKey(key: string, agentDir?: string) {
   });
 }
 
-export async function setKimiCodeApiKey(key: string, agentDir?: string) {
+export async function setKimiCodingApiKey(key: string, agentDir?: string) {
   // Write to resolved agent dir so gateway finds credentials on startup.
   upsertAuthProfile({
-    profileId: "kimi-code:default",
+    profileId: "kimi-coding:default",
     credential: {
       type: "api_key",
-      provider: "kimi-code",
+      provider: "kimi-coding",
       key,
     },
     agentDir: resolveAuthAgentDir(agentDir),

src/commands/onboard-auth.models.ts

@@ -12,13 +12,8 @@ export const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2-0905-preview";
 export const MOONSHOT_DEFAULT_MODEL_REF = `moonshot/${MOONSHOT_DEFAULT_MODEL_ID}`;
 export const MOONSHOT_DEFAULT_CONTEXT_WINDOW = 256000;
 export const MOONSHOT_DEFAULT_MAX_TOKENS = 8192;
-export const KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
+export const KIMI_CODING_MODEL_ID = "k2p5";
-export const KIMI_CODE_MODEL_ID = "kimi-for-coding";
+export const KIMI_CODING_MODEL_REF = `kimi-coding/${KIMI_CODING_MODEL_ID}`;
-export const KIMI_CODE_MODEL_REF = `kimi-code/${KIMI_CODE_MODEL_ID}`;
-export const KIMI_CODE_CONTEXT_WINDOW = 262144;
-export const KIMI_CODE_MAX_TOKENS = 32768;
-export const KIMI_CODE_HEADERS = { "User-Agent": "KimiCLI/0.77" } as const;
-export const KIMI_CODE_COMPAT = { supportsDeveloperRole: false } as const;
 
 // Pricing: MiniMax doesn't publish public rates. Override in models.json for accurate costs.
 export const MINIMAX_API_COST = {
@@ -45,12 +40,6 @@ export const MOONSHOT_DEFAULT_COST = {
   cacheRead: 0,
   cacheWrite: 0,
 };
-export const KIMI_CODE_DEFAULT_COST = {
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-};
 
 const MINIMAX_MODEL_CATALOG = {
   "MiniMax-M2.1": { name: "MiniMax M2.1", reasoning: false },
@@ -102,17 +91,3 @@ export function buildMoonshotModelDefinition(): ModelDefinitionConfig {
     maxTokens: MOONSHOT_DEFAULT_MAX_TOKENS,
   };
 }
-
-export function buildKimiCodeModelDefinition(): ModelDefinitionConfig {
-  return {
-    id: KIMI_CODE_MODEL_ID,
-    name: "Kimi For Coding",
-    reasoning: true,
-    input: ["text"],
-    cost: KIMI_CODE_DEFAULT_COST,
-    contextWindow: KIMI_CODE_CONTEXT_WINDOW,
-    maxTokens: KIMI_CODE_MAX_TOKENS,
-    headers: KIMI_CODE_HEADERS,
-    compat: KIMI_CODE_COMPAT,
-  };
-}

src/commands/onboard-auth.ts

@@ -38,7 +38,7 @@ export {
   OPENROUTER_DEFAULT_MODEL_REF,
   setAnthropicApiKey,
   setGeminiApiKey,
-  setKimiCodeApiKey,
+  setKimiCodingApiKey,
   setMinimaxApiKey,
   setMoonshotApiKey,
   setOpencodeZenApiKey,
@@ -54,14 +54,12 @@ export {
   ZAI_DEFAULT_MODEL_REF,
 } from "./onboard-auth.credentials.js";
 export {
-  buildKimiCodeModelDefinition,
   buildMinimaxApiModelDefinition,
   buildMinimaxModelDefinition,
   buildMoonshotModelDefinition,
   DEFAULT_MINIMAX_BASE_URL,
-  KIMI_CODE_BASE_URL,
+  KIMI_CODING_MODEL_ID,
-  KIMI_CODE_MODEL_ID,
+  KIMI_CODING_MODEL_REF,
-  KIMI_CODE_MODEL_REF,
   MINIMAX_API_BASE_URL,
   MINIMAX_HOSTED_MODEL_ID,
   MINIMAX_HOSTED_MODEL_REF,

src/commands/onboard-non-interactive/local/auth-choice.ts

@@ -21,7 +21,7 @@ import {
   applyZaiConfig,
   setAnthropicApiKey,
   setGeminiApiKey,
-  setKimiCodeApiKey,
+  setKimiCodingApiKey,
   setMinimaxApiKey,
   setMoonshotApiKey,
   setOpencodeZenApiKey,
@@ -275,18 +275,18 @@ export async function applyNonInteractiveAuthChoice(params: {
 
   if (authChoice === "kimi-code-api-key") {
     const resolved = await resolveNonInteractiveApiKey({
-      provider: "kimi-code",
+      provider: "kimi-coding",
       cfg: baseConfig,
       flagValue: opts.kimiCodeApiKey,
       flagName: "--kimi-code-api-key",
-      envVar: "KIMICODE_API_KEY",
+      envVar: "KIMI_API_KEY",
       runtime,
     });
     if (!resolved) return null;
-    if (resolved.source !== "profile") await setKimiCodeApiKey(resolved.key);
+    if (resolved.source !== "profile") await setKimiCodingApiKey(resolved.key);
     nextConfig = applyAuthProfileConfig(nextConfig, {
-      profileId: "kimi-code:default",
+      profileId: "kimi-coding:default",
-      provider: "kimi-code",
+      provider: "kimi-coding",
       mode: "api_key",
     });
     return applyKimiCodeConfig(nextConfig);