feat(kimi): merge OAuth into dual-auth provider, add K3/K2.7 models

Gộp kimi-coding vào kimi (oauth+apikey), parity CLIProxyAPI device flow/headers/refresh. Thêm K3 + K2.7 Code (+ Kimi Code ids), pricing/caps vision, cập nhật baseline. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-07-17 12:09:14 +07:00
parent bc252ea802
commit 68566f53dc
21 changed files with 332 additions and 228 deletions
--- a/src/app/(dashboard)/dashboard/providers/[id]/page.js
+++ b/src/app/(dashboard)/dashboard/providers/[id]/page.js
@@ -4,6 +4,7 @@ import { useState, useEffect, useCallback, useRef } from "react";
 import { useParams, useRouter } from "next/navigation";
 import Link from "next/link";
 import Image from "next/image";
+import { getProviderIconSrc, markProviderIconMissing } from "@/shared/utils/providerIcon";
 import { Card, Button, Badge, Input, Modal, CardSkeleton, OAuthModal, KiroOAuthWrapper, CursorAuthModal, IFlowCookieModal, GitLabAuthModal, Toggle, Select, EditConnectionModal, NoAuthProxyCard, ConfirmModal } from "@/shared/components";
 import { OAUTH_PROVIDERS, APIKEY_PROVIDERS, FREE_PROVIDERS, FREE_TIER_PROVIDERS, WEB_COOKIE_PROVIDERS, getProviderAlias, isOpenAICompatibleProvider, isAnthropicCompatibleProvider, AI_PROVIDERS } from "@/shared/constants/providers";
 import { getModelsByProviderId, getModelKind } from "@/shared/constants/models";
@@ -151,8 +152,12 @@ export default function ProviderDetailPage() {
  const oauthConnectionLabel =
    providerId === "xai" ? "Grok Build OAuth"
    : providerId === "grok-cli" ? "Grok CLI Device Login"
+    : providerId === "kimi" ? "Kimi Coding OAuth"
    : "OAuth";
-  const apiKeyConnectionLabel = providerId === "xai" ? "xAI API Key" : "API Key";
+  const apiKeyConnectionLabel =
+    providerId === "xai" ? "xAI API Key"
+    : providerId === "kimi" ? "Kimi API Key"
+    : "API Key";
  // Resolve suffix "(level)" for a model when a thinking level is picked and the model supports it.
  const resolveThinkingSuffix = (modelId) => {
    if (!thinkingMode || thinkingMode === "auto") return null;
@@ -1231,7 +1236,7 @@ export default function ProviderDetailPage() {
    if (isAnthropicCompatible) {
      return "/providers/anthropic-m.png";
    }
-    return `/providers/${providerInfo.id}.png`;
+    return getProviderIconSrc(providerInfo.id);
  };

  return (
@@ -1250,7 +1255,7 @@ export default function ProviderDetailPage() {
            className="flex size-12 shrink-0 items-center justify-center rounded-lg"
            style={{ backgroundColor: `${providerInfo.color}15` }}
          >
-            {headerImgError ? (
+            {headerImgError || !getHeaderIconPath() ? (
              <span className="text-sm font-bold" style={{ color: providerInfo.color }}>
                {providerInfo.textIcon || providerInfo.id.slice(0, 2).toUpperCase()}
              </span>
@@ -1262,7 +1267,12 @@ export default function ProviderDetailPage() {
                height={48}
                className="max-h-12 max-w-12 rounded-lg object-contain"
                sizes="48px"
-                onError={() => setHeaderImgError(true)}
+                onError={() => {
+                  markProviderIconMissing(providerInfo.id);
+                  setHeaderImgError(true);
+                }}
+              loading="lazy"
+              decoding="async"
              />
            )}
          </div>
--- a/src/app/api/oauth/[provider]/[action]/route.js
+++ b/src/app/api/oauth/[provider]/[action]/route.js
@@ -154,6 +154,7 @@ export async function GET(request, { params }) {
      const noPkceDeviceProviders = [
        "github",
        "kiro",
+        "kimi",
        "kimi-coding",
        "kilocode",
        "codebuddy-cn",
@@ -279,10 +280,11 @@ export async function POST(request, { params }) {
      }

      // Providers that don't use PKCE for device code
-      const noPkceProviders = ["github", "kimi-coding", "kilocode", "codebuddy-cn"];
+      const noPkceProviders = ["github", "kimi", "kimi-coding", "kilocode", "codebuddy-cn"];
      let result;
      if (noPkceProviders.includes(provider)) {
-        result = await pollForToken(provider, deviceCode);
+        // kimi needs extraData._kimiDeviceId for stable X-Msh-Device-Id (CLIProxyAPI parity)
+        result = await pollForToken(provider, deviceCode, null, extraData);
      } else if (provider === "kiro") {
        // Kiro needs extraData (clientId, clientSecret) from device code response
        result = await pollForToken(provider, deviceCode, null, extraData);
@@ -303,9 +305,10 @@ export async function POST(request, { params }) {
      }

      if (result.success) {
-        // Save to database
+        // Save to database (legacy kimi-coding OAuth → dual-auth kimi)
+        const providerId = provider === "kimi-coding" ? "kimi" : provider;
        const connection = await createProviderConnection({
-          provider,
+          provider: providerId,
          authType: "oauth",
          ...result.tokens,
          expiresAt: result.tokens.expiresIn 
--- a/src/app/api/providers/[id]/test/testUtils.js
+++ b/src/app/api/providers/[id]/test/testUtils.js
@@ -75,7 +75,8 @@ const OAUTH_TEST_CONFIG = {
    authPrefix: "Bearer ",
    refreshable: false,
  },
-  "kimi-coding": { checkExpiry: true, refreshable: false },
+  kimi: { checkExpiry: true, refreshable: true },
+  "kimi-coding": { checkExpiry: true, refreshable: true },
  cursor: { tokenExists: true },
  kilocode: {
    url: `${KILOCODE_CONFIG.apiBaseUrl}/api/profile`,
--- a/src/lib/oauth/constants/oauth.js
+++ b/src/lib/oauth/constants/oauth.js
@@ -89,12 +89,18 @@ export const CURSOR_CONFIG = {
  },
 };

-// Kimi Coding OAuth Configuration (Device Code Flow)
-// clientId uses env override — dynamic, not stored in registry
-export const KIMI_CODING_CONFIG = {
-  ...PROVIDER_OAUTH["kimi-coding"],
-  clientId: process.env.KIMI_CODING_OAUTH_CLIENT_ID || REGISTRY_PROVIDERS["kimi-coding"]?.clientId,
+// Kimi Code OAuth (Device Code Flow) — merged into provider id `kimi` (dual auth)
+// clientId: registry first, env override for forks
+export const KIMI_CONFIG = {
+  ...PROVIDER_OAUTH["kimi"],
+  clientId:
+    process.env.KIMI_CODING_OAUTH_CLIENT_ID ||
+    process.env.KIMI_OAUTH_CLIENT_ID ||
+    REGISTRY_PROVIDERS["kimi"]?.clientId ||
+    PROVIDER_OAUTH["kimi"]?.clientId,
 };
+// Back-compat alias for any remaining KIMI_CODING_CONFIG imports
+export const KIMI_CODING_CONFIG = KIMI_CONFIG;

 // KiloCode OAuth Configuration (Custom Device Auth Flow)
 export const KILOCODE_CONFIG = { ...PROVIDER_OAUTH["kilocode"] };
@@ -134,7 +140,8 @@ export const PROVIDERS = {
  GITHUB: "github",
  KIRO: "kiro",
  CURSOR: "cursor",
-  KIMI_CODING: "kimi-coding",
+  KIMI: "kimi",
+  KIMI_CODING: "kimi",
  KILOCODE: "kilocode",
  CLINE: "cline",
  CLINEPASS: "clinepass",
--- a/src/lib/oauth/providers.js
+++ b/src/lib/oauth/providers.js
@@ -20,7 +20,7 @@ import {
  KIRO_CONFIG,
  assertValidAwsRegion,
  CURSOR_CONFIG,
-  KIMI_CODING_CONFIG,
+  KIMI_CONFIG,
  KILOCODE_CONFIG,
  CLINE_CONFIG,
  CLINEPASS_CONFIG,
@@ -1081,13 +1081,22 @@ const PROVIDERS = {
    }),
  },

-  "kimi-coding": {
-    config: KIMI_CODING_CONFIG,
+  // Kimi Code device flow (CLIProxyAPI internal/auth/kimi). Id is `kimi`;
+  // `kimi-coding` remains an alias key so old UI/API routes still resolve.
+  kimi: {
+    config: KIMI_CONFIG,
    flowType: "device_code",
    requestDeviceCode: async (config) => {
+      const { buildKimiHeaders } = await import("open-sse/config/appConstants.js");
+      const deviceId = crypto.randomUUID();
+      const headers = {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        ...buildKimiHeaders(deviceId),
+      };
      const response = await fetch(config.deviceCodeUrl, {
        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+        headers,
        body: new URLSearchParams({ client_id: config.clientId }),
      });
      if (!response.ok) {
@@ -1095,21 +1104,30 @@ const PROVIDERS = {
        throw new Error(`Device code request failed: ${error}`);
      }
      const data = await response.json();
+      const authorizeDeviceUrl = config.authorizeDeviceUrl || "https://www.kimi.com/code/authorize_device";
      return {
        device_code: data.device_code,
        user_code: data.user_code,
-        verification_uri: data.verification_uri || "https://www.kimi.com/code/authorize_device",
+        verification_uri: data.verification_uri || authorizeDeviceUrl,
        verification_uri_complete:
          data.verification_uri_complete ||
-          `https://www.kimi.com/code/authorize_device?user_code=${data.user_code}`,
+          `${authorizeDeviceUrl}?user_code=${data.user_code}`,
        expires_in: data.expires_in,
        interval: data.interval || 5,
+        _kimiDeviceId: deviceId,
      };
    },
-    pollToken: async (config, deviceCode) => {
+    pollToken: async (config, deviceCode, _codeVerifier, extraData) => {
+      const { buildKimiHeaders } = await import("open-sse/config/appConstants.js");
+      const deviceId = extraData?._kimiDeviceId;
+      const headers = {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        ...buildKimiHeaders(deviceId),
+      };
      const response = await fetch(config.tokenUrl, {
        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+        headers,
        body: new URLSearchParams({
          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
          client_id: config.clientId,
@@ -1119,19 +1137,26 @@ const PROVIDERS = {
      let data;
      try {
        data = await response.json();
-      } catch (e) {
-        const text = await response.text();
-        data = { error: "invalid_response", error_description: text };
+      } catch {
+        data = { error: "invalid_response", error_description: "non-json token response" };
      }
-      return { ok: response.ok, data };
+      // CLIProxyAPI: Kimi returns 200 for pending states with error field
+      if (data.error === "authorization_pending" || data.error === "slow_down") {
+        return { ok: true, data };
+      }
+      if (data.access_token && deviceId) data._kimiDeviceId = deviceId;
+      return { ok: response.ok || !!data.access_token || !!data.error, data };
    },
    mapTokens: (tokens) => ({
      accessToken: tokens.access_token,
      refreshToken: tokens.refresh_token,
      expiresIn: tokens.expires_in,
+      providerSpecificData: {
+        authMethod: "device_code",
+        ...(tokens._kimiDeviceId ? { deviceId: tokens._kimiDeviceId } : {}),
+      },
    }),
  },
-
  kilocode: {
    config: KILOCODE_CONFIG,
    flowType: "device_code",
@@ -1520,7 +1545,9 @@ const PROVIDERS = {
 * Get provider handler
 */
 export function getProvider(name) {
-  const provider = PROVIDERS[name];
+  // Legacy kimi-coding → kimi (dual-auth merge)
+  const key = name === "kimi-coding" ? "kimi" : name;
+  const provider = PROVIDERS[key];
  if (!provider) {
    throw new Error(`Unknown provider: ${name}`);
  }
--- a/src/shared/components/OAuthModal.js
+++ b/src/shared/components/OAuthModal.js
@@ -161,6 +161,7 @@ export default function OAuthModal({ isOpen, provider, providerInfo, onSuccess,
        "github",
        "qwen",
        "kiro",
+        "kimi",
        "kimi-coding",
        "kilocode",
        "codebuddy-cn",
@@ -206,6 +207,8 @@ export default function OAuthModal({ isOpen, provider, providerInfo, onSuccess,
              _qoderMachineId: data._qoderMachineId,
              _qoderVerifier: data.codeVerifier,
            }
+          : (provider === "kimi" || provider === "kimi-coding")
+          ? { _kimiDeviceId: data._kimiDeviceId }
          : null;
        startPolling(
          data.device_code,