@kenkaiiii/gg-core 5.93.0 → 5.95.0

package/dist/index.js

@@ -1,30 +1,52 @@
 import {
   AuthStorage,
+  CHATGPT_PLAN_BASE_URL,
+  CHATGPT_PLAN_NOT_ENABLED_MESSAGE,
+  CHATGPT_PLAN_SCOPE,
+  CHATGPT_USAGE_URL,
+  CLAUDE_CODE_AUTH_KEY,
+  CLAUDE_CODE_AUTH_MARKER,
+  CLAUDE_CODE_MANIFEST,
+  ChatGPTPlanNotEnabledError,
   DEFAULT_MAX_VIDEO_BYTES,
   GEMINI_API_KEY,
   GEMINI_API_KEY_BASE_URL,
   HIDDEN_PROVIDERS,
+  KIMI_CODE_DEFAULT_BASE_URL,
+  KIMI_CODE_KEY,
+  KIMI_CODE_OVERSEAS_BASE_URL,
   LOCAL_AUTH_KEY_PREFIX,
   MINIMAX_CN_BASE_URL,
   MINIMAX_GLOBAL_BASE_URL,
   MODELS,
-  MOONSHOT_OAUTH_KEY,
   NotLoggedInError,
-  XAI_OAUTH_KEY,
+  OPENAI_CHATGPT_KEY,
+  RETIRED_SIGN_INS,
   XIAOMI_CREDITS_KEY,
   XIAOMI_TOKEN_PLAN_BASE_URLS,
+  apiKeyStorageKeys,
+  claudeCodeAuthStatus,
+  claudeCodeBinaryPath,
+  claudeCodeCallbackUrl,
+  claudeCodeConfigDir,
+  claudeCodeEnv,
+  claudeCodeHome,
+  claudeCodePlatformKey,
   clearRuntimeModels,
   closeLogger,
+  detectKimiCodeBaseUrl,
   detectMiniMaxBaseUrl,
   detectXiaomiTokenPlanBaseUrl,
   dualAuthProvider,
   dualAuthProviderByOAuthKey,
+  ensureClaudeCodeBinary,
+  fetchChatGPTPlanModels,
+  formatClaudeCodeInstallProgress,
   generatePKCE,
   getAllModels,
   getAuthStorageKey,
   getAuthStorageKeys,
-  getClaudeCliUserAgent,
-  getClaudeCodeVersion,
+  getChatGPTHostId,
   getContextWindow,
   getDefaultModel,
   getDefaultThinkingLevel,
@@ -37,41 +59,36 @@ import {
   getSummaryModel,
   getToolResultCharLimit,
   getVideoByteLimit,
-  grokCliBaseUrl,
-  grokCliHeaders,
-  isGrokCliEndpoint,
+  isClaudeCodeAuthMarker,
   isHiddenProvider,
   isKimiCodingEndpoint,
+  isLegacyClaudeOAuth,
   isLoggerOpen,
   isPaidModel,
-  kimiCodeBaseUrl,
-  kimiCodingHeaders,
   log,
-  loginAnthropic,
-  loginGemini,
-  loginKimi,
-  loginOpenAI,
-  loginXai,
+  loginChatGPT,
+  loginClaudeCode,
+  logoutClaudeCode,
   oauthStorageKey,
   openLog,
-  pendingClaudeCodeVersionRefresh,
+  parseCallbackInput,
   providerStorageKeys,
   readStoredBaseUrlSync,
-  refreshAnthropicToken,
-  refreshGeminiToken,
-  refreshKimiToken,
-  refreshOpenAIToken,
-  refreshXaiToken,
+  refreshChatGPTToken,
   registerLogCleanup,
   registerRuntimeModels,
+  resolveClaudeCodeBinary,
+  revokeChatGPTSignIn,
   setProviderCatalog,
+  storageKeyProvider,
   usesOpenAICodexTransport,
+  verifyIdToken,
   withFileLock,
   withoutPaidTier
-} from "./chunk-SDUIKPGO.js";
+} from "./chunk-J7W5HS6X.js";
 import {
   getAppPaths
-} from "./chunk-2X5L6U4Z.js";
+} from "./chunk-GXOFTHM5.js";
 
 // src/openrouter-catalog.ts
 var OPENROUTER_DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
@@ -587,101 +604,238 @@ function findProbedModel(probes, modelId) {
   return void 0;
 }
 
+// src/claude-code/usage.ts
+import fsp from "fs/promises";
+import path from "path";
+var USAGE_FILE = "usage.json";
+var WINDOWS = {
+  five_hour: { kind: "current", label: "5-hour" },
+  seven_day: { kind: "weekly", label: "Weekly" }
+};
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function toWindow(key, raw) {
+  const shape = WINDOWS[key];
+  const fraction = finite(raw?.utilization);
+  if (!shape || fraction === void 0) return null;
+  const resetsAt = finite(raw?.resetsAt);
+  return {
+    ...shape,
+    usedPercent: Math.min(100, Math.max(0, fraction * 100)),
+    ...resetsAt !== void 0 ? { resetsAt: resetsAt * 1e3 } : {}
+  };
+}
+function mergeClaudeCodeRateLimit(info, previous, now = Date.now()) {
+  const reported = info.unifiedWindows ? Object.entries(info.unifiedWindows).map(([key, raw]) => toWindow(key, raw)) : info.rateLimitType ? [toWindow(info.rateLimitType, info)] : [];
+  const byKind = new Map(previous?.windows.map((w) => [w.kind, w]) ?? []);
+  for (const window of reported) if (window) byKind.set(window.kind, window);
+  const windows = [...byKind.values()].sort(
+    (a, b) => a.kind === b.kind ? 0 : a.kind === "current" ? -1 : 1
+  );
+  return { provider: "anthropic", displayName: "Anthropic", windows, fetchedAt: now };
+}
+function usagePath(opts) {
+  return path.join(claudeCodeHome(opts), USAGE_FILE);
+}
+async function readClaudeCodeUsage(opts = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await fsp.readFile(usagePath(opts), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed?.windows) || typeof parsed.fetchedAt !== "number") return null;
+  const now = opts.now ?? Date.now();
+  const windows = parsed.windows.filter(
+    (w) => (w.kind === "current" || w.kind === "weekly") && typeof w.usedPercent === "number" && (w.resetsAt === void 0 || w.resetsAt > now)
+  );
+  return { provider: "anthropic", displayName: "Anthropic", windows, fetchedAt: parsed.fetchedAt };
+}
+var writeQueue = Promise.resolve();
+function recordClaudeCodeRateLimit(info, opts = {}) {
+  const write = async () => {
+    const now = opts.now ?? Date.now();
+    const next = mergeClaudeCodeRateLimit(info, await readClaudeCodeUsage({ ...opts, now }), now);
+    if (next.windows.length === 0) return;
+    const file = usagePath(opts);
+    await fsp.mkdir(path.dirname(file), { recursive: true });
+    await fsp.writeFile(file, JSON.stringify(next), "utf8");
+  };
+  writeQueue = writeQueue.then(write).catch(() => {
+  });
+  return writeQueue;
+}
+async function clearClaudeCodeUsage(opts = {}) {
+  await writeQueue;
+  await fsp.rm(usagePath(opts), { force: true }).catch(() => {
+  });
+}
+
+// src/claude-code/sign-in.ts
+async function signInWithClaudeCode(auth, callbacks, opts = {}) {
+  if (!opts.binary && !resolveClaudeCodeBinary(opts)) {
+    callbacks.onStatus("Downloading Claude Code (one time)\u2026");
+    await ensureClaudeCodeBinary({
+      ...opts,
+      onProgress: (progress) => {
+        callbacks.onStatus(formatClaudeCodeInstallProgress(progress));
+        opts.onProgress?.(progress);
+      }
+    });
+  }
+  let status = await claudeCodeAuthStatus(opts);
+  if (!status.loggedIn) {
+    callbacks.onStatus("Opening Claude sign-in\u2026");
+    await loginClaudeCode(callbacks, opts);
+    status = await claudeCodeAuthStatus(opts);
+  }
+  if (!status.loggedIn) throw new Error("Claude sign-in didn't finish. Try again.");
+  await auth.setClaudeCodeLogin();
+  return status;
+}
+async function signOutOfClaudeCode(auth, opts = {}) {
+  await auth.clearClaudeCodeLogin();
+  await clearClaudeCodeUsage(opts);
+  try {
+    await logoutClaudeCode(opts);
+  } catch (err) {
+    log(
+      "WARN",
+      "auth",
+      `claude auth logout failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
 // src/auth-providers.ts
+function apiKeyDetails(label, billing, when = "") {
+  return { apikey: { method: "apikey", label, billing, when } };
+}
 var ALL_AUTH_PROVIDERS = [
   {
     value: "anthropic",
     label: "Anthropic",
     description: "Claude Fable 5.1, Opus 5.5, Opus 5.5 Fast, Sonnet 5.5, Haiku 5.5",
-    methods: ["oauth"]
-  },
-  {
-    value: "openai",
-    label: "OpenAI",
-    description: "GPT-6 Astra, GPT-6 Astra Fast, GPT-6.1 Sol, GPT-6.1 Sol Fast, GPT-6 Luna, GPT-6 Luna Fast",
-    methods: ["oauth"]
-  },
-  {
-    value: "gemini",
-    label: "Gemini",
-    description: "Gemini 3.8 Flash, 3.5 Flash Lite, 3.1 Flash Lite, 3.5 Flash, 3.1 Pro (Preview)",
     methods: ["oauth", "apikey"],
-    apiKeyLabel: "Gemini",
-    apiKeyBaseUrl: GEMINI_API_KEY_BASE_URL,
-    // Stored under its own key so it never overwrites the `gemini` OAuth login.
-    apiKeyVariants: [
-      { key: GEMINI_API_KEY, label: "Google AI Studio", baseUrl: GEMINI_API_KEY_BASE_URL }
-    ],
+    apiKeyLabel: "Anthropic",
     methodDetails: {
       oauth: {
         method: "oauth",
-        label: "Sign in with Google",
-        billing: "Gemini Code Assist Standard or Enterprise licence.",
-        when: "Personal Google accounts are no longer served here (Google ended it on June 18, 2026)."
+        label: "Sign in with Claude",
+        billing: "Uses your Claude Pro or Max plan.",
+        when: "Runs through Anthropic's Claude Code, which GG Coder downloads once (about 140 MB) the first time you pick this.",
+        requires: "A Claude Pro or Max subscription."
       },
       apikey: {
         method: "apikey",
-        label: "Gemini API key",
-        billing: "Pay-per-token from a Google AI Studio key.",
-        when: "Used first whenever it is set."
+        label: "Anthropic API key",
+        billing: "Pay-per-token from an Anthropic Console key.",
+        when: "No subscription needed. Used only while you are not signed in with Claude."
       }
     }
   },
   {
-    value: "xai",
-    label: "xAI (Grok)",
-    description: "Grok 4.7 \xB7 OAuth or API key",
+    value: "openai",
+    label: "OpenAI",
+    description: "GPT-6 Astra, GPT-6 Astra Fast, GPT-6.1 Sol, GPT-6.1 Sol Fast, GPT-6.1 Terra, GPT-6.1 Terra Fast, GPT-6 Luna, GPT-6 Luna Fast",
     methods: ["oauth", "apikey"],
-    apiKeyLabel: "xAI",
+    apiKeyLabel: "OpenAI",
     methodDetails: {
       oauth: {
         method: "oauth",
-        label: "Sign in with Grok",
-        billing: "Included with SuperGrok or X Premium.",
-        when: ""
+        label: "Continue with ChatGPT",
+        billing: "Uses your ChatGPT plan.",
+        when: "Signs in through OpenAI. Manage what GG Coder may use at chatgpt.com/settings/usage.",
+        requires: "A ChatGPT plan."
       },
       apikey: {
         method: "apikey",
-        label: "xAI API key",
-        billing: "Pay-per-token on console.x.ai credits.",
-        when: ""
+        label: "OpenAI API key",
+        billing: "Pay-per-token from an OpenAI Platform key.",
+        when: "No subscription needed. Covers you while your ChatGPT plan's usage is out."
       }
     }
   },
+  {
+    value: "gemini",
+    label: "Gemini",
+    description: "Gemini 3.8 Flash, 3.5 Flash Lite, 3.1 Flash Lite, 3.5 Flash, 3.1 Pro (Preview)",
+    methods: ["apikey"],
+    apiKeyLabel: "Gemini",
+    apiKeyBaseUrl: GEMINI_API_KEY_BASE_URL,
+    // Stored under its own key: `gemini` held the retired Google sign-in.
+    apiKeyVariants: [
+      {
+        key: GEMINI_API_KEY,
+        label: "Google AI Studio",
+        kind: "payg",
+        billing: "Pay-per-token from a Google AI Studio key.",
+        baseUrl: GEMINI_API_KEY_BASE_URL
+      }
+    ],
+    methodDetails: apiKeyDetails("Gemini API key", "Pay-per-token from a Google AI Studio key.")
+  },
+  {
+    value: "xai",
+    label: "xAI (Grok)",
+    description: "Grok 4.7",
+    methods: ["apikey"],
+    apiKeyLabel: "xAI",
+    methodDetails: apiKeyDetails(
+      "xAI API key",
+      "Pay-per-token from console.x.ai credits.",
+      "SuperGrok and X Premium usage is only offered in apps xAI partners with."
+    )
+  },
   {
     value: "moonshot",
-    label: "Moonshot",
-    description: "Kimi K3, K2.8 Preview (Kimi sign-in), K2.7 Code, K2.7 Code HighSpeed \xB7 OAuth or API key",
-    methods: ["oauth", "apikey"],
-    apiKeyLabel: "Moonshot",
-    methodDetails: {
-      oauth: {
-        method: "oauth",
-        label: "Sign in with Kimi",
-        billing: "Included with a Kimi For Coding plan.",
-        when: ""
+    label: "Kimi (Moonshot)",
+    description: "Kimi K3, K2.8 Preview (Kimi Code plan), K2.7 Code, K2.7 Code HighSpeed",
+    methods: ["apikey"],
+    apiKeyLabel: "Kimi",
+    apiKeyVariants: [
+      {
+        key: KIMI_CODE_KEY,
+        label: "Kimi Code plan",
+        kind: "plan",
+        billing: "Uses your Kimi Code plan. Create the key in the Kimi Code Console."
       },
-      apikey: {
-        method: "apikey",
-        label: "Moonshot API key",
-        billing: "Pay-per-token on Moonshot credits.",
-        when: ""
+      {
+        key: "moonshot",
+        label: "Moonshot API",
+        kind: "payg",
+        billing: "Pay-per-token from platform.moonshot.ai."
       }
-    }
+    ],
+    methodDetails: apiKeyDetails(
+      "Kimi API key",
+      "A Kimi Code plan key uses your plan; a Moonshot key is pay-per-token."
+    )
   },
   {
     value: "glm",
     label: "Z.AI (GLM)",
     description: "GLM-5.3, GLM-5.3-Flash",
     methods: ["apikey"],
-    apiKeyLabel: "Z.AI"
+    apiKeyLabel: "Z.AI",
+    methodDetails: apiKeyDetails(
+      "Z.AI API key",
+      "Pay-per-token from your Z.AI account balance.",
+      "GLM Coding Plan quota can't be used here: Z.AI limits the plan to the tools it lists."
+    )
   },
   {
     value: "minimax",
     label: "MiniMax",
     description: "MiniMax M3.1 Flash, M3",
     methods: ["apikey"],
-    apiKeyLabel: "MiniMax"
+    apiKeyLabel: "MiniMax",
+    methodDetails: apiKeyDetails(
+      "MiniMax API key",
+      "An M Plan key uses your plan; a pay-as-you-go key is pay-per-token.",
+      "The key you paste decides which one is billed."
+    )
   },
   {
     value: "xiaomi",
@@ -694,44 +848,66 @@ var ALL_AUTH_PROVIDERS = [
       {
         key: "xiaomi",
         label: "Token Plan",
+        kind: "plan",
+        billing: "Uses your MiMo Token Plan.",
         baseUrl: "https://token-plan-sgp.xiaomimimo.com/v1"
       },
       {
         key: XIAOMI_CREDITS_KEY,
-        label: "API Credits (required for UltraSpeed)",
+        label: "API Credits",
+        kind: "payg",
+        billing: "Pay-per-token from MiMo API Credits. Required for UltraSpeed.",
         baseUrl: "https://api.xiaomimimo.com/v1"
       }
-    ]
+    ],
+    methodDetails: apiKeyDetails(
+      "Xiaomi MiMo API key",
+      "A Token Plan key uses your plan; an API Credits key is pay-per-token."
+    )
   },
   {
     value: "deepseek",
     label: "DeepSeek",
     description: "DeepSeek V4 Pro, V4.1 Flash",
     methods: ["apikey"],
-    apiKeyLabel: "DeepSeek"
+    apiKeyLabel: "DeepSeek",
+    methodDetails: apiKeyDetails("DeepSeek API key", "Pay-per-token from platform.deepseek.com.")
   },
   {
     value: "sakana",
     label: "Sakana (Fugu)",
     description: "Fugu, Fugu Max, Fugu Ultra",
     methods: ["apikey"],
-    apiKeyLabel: "Sakana"
+    apiKeyLabel: "Sakana",
+    methodDetails: apiKeyDetails("Sakana API key", "Pay-per-token from your Sakana API account.")
   },
   {
     value: "openrouter",
     label: "OpenRouter",
     description: "Qwen3.8 Max \xB7 multi-provider gateway",
     methods: ["apikey"],
-    apiKeyLabel: "OpenRouter"
+    apiKeyLabel: "OpenRouter",
+    methodDetails: apiKeyDetails("OpenRouter API key", "Pay-per-token from OpenRouter credits.")
   },
   {
     value: "huggingface",
     label: "Hugging Face",
     description: "Kimi K2.7 Code, DeepSeek V4.1 Flash, GPT-OSS 120B",
     methods: ["apikey"],
-    apiKeyLabel: "Hugging Face"
+    apiKeyLabel: "Hugging Face",
+    methodDetails: apiKeyDetails(
+      "Hugging Face token",
+      "Pay-per-token from Hugging Face Inference Providers credits."
+    )
   }
 ];
+function requiredKeyLabel(provider, storageKeys) {
+  const variants = ALL_AUTH_PROVIDERS.find((p) => p.value === provider)?.apiKeyVariants ?? [];
+  const needed = variants.filter((v) => storageKeys.includes(v.key));
+  if (needed.length === 0 || needed.length === variants.length) return void 0;
+  const names = needed.map((v) => v.label).join(" or ");
+  return `Needs ${/^[aeiou]/i.test(names) ? "an" : "a"} ${names} key`;
+}
 var AUTH_PROVIDERS = ALL_AUTH_PROVIDERS.filter(
   (p) => !isHiddenProvider(p.value)
 );
@@ -758,15 +934,24 @@ function describeAuthMethods(provider) {
   });
 }
 function authPriorityNote(provider) {
-  if (provider === "gemini") {
-    return "Uses the Gemini API key first when one is set; otherwise the Google sign-in.";
+  if (provider === "anthropic") {
+    return "Uses Sign in with Claude while you are signed in; otherwise the Anthropic API key.";
   }
   const dual = dualAuthProvider(provider);
-  if (!dual) return void 0;
-  return `Uses ${dual.oauthLabel} first; the ${dual.apiKeyLabel} takes over when it runs out, then switches back.`;
+  if (dual) {
+    return `Uses your ${dual.oauthLabel} first; the ${dual.apiKeyLabel} takes over while its usage is out, then switches back.`;
+  }
+  const variants = getAuthProvider(provider)?.apiKeyVariants;
+  const plan = variants?.find((v) => v.kind === "plan");
+  const payg = variants?.find((v) => v.kind === "payg");
+  if (plan && payg) {
+    return `Uses the ${plan.label} key first when both are set; the ${payg.label} key covers models the plan doesn't include.`;
+  }
+  return void 0;
 }
 
 // src/provider-usage.ts
+import { GG_CODER_USER_AGENT } from "@kenkaiiii/gg-ai";
 var SubscriptionUsageError = class extends Error {
   constructor(message, status, retryAfterMs2) {
     super(message);
@@ -775,52 +960,14 @@ var SubscriptionUsageError = class extends Error {
     this.name = "SubscriptionUsageError";
   }
 };
-var ANTHROPIC_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
-var CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function clampPercent(value) {
-  const number = finiteNumber(value);
-  return number === void 0 ? void 0 : Math.min(100, Math.max(0, number));
-}
 function isoTimestamp(value) {
   if (typeof value !== "string" || !value.trim()) return void 0;
   const timestamp = Date.parse(value);
   return Number.isFinite(timestamp) ? timestamp : void 0;
 }
-function unixTimestamp(value) {
-  const seconds = finiteNumber(value);
-  return seconds === void 0 ? void 0 : seconds * 1e3;
-}
-function codexResetAt(window, now) {
-  const absolute = unixTimestamp(window.reset_at);
-  if (absolute !== void 0) return absolute;
-  const afterSeconds = finiteNumber(window.reset_after_seconds);
-  return afterSeconds === void 0 ? void 0 : now + afterSeconds * 1e3;
-}
-function currentWindowLabel(seconds, fallbackHours) {
-  const duration = finiteNumber(seconds);
-  const hours = Math.max(1, Math.round((duration ?? fallbackHours * 3600) / 3600));
-  return `${hours}-hour`;
-}
-function codexWindowKind(window, fallback) {
-  const duration = finiteNumber(window.limit_window_seconds);
-  if (duration === void 0) return fallback;
-  return duration >= 6 * 24 * 60 * 60 ? "weekly" : "current";
-}
-function normalizedCodexWindow(window, fallbackKind, now) {
-  if (!window) return null;
-  const usedPercent = clampPercent(window.used_percent);
-  if (usedPercent === void 0) return null;
-  const kind = codexWindowKind(window, fallbackKind);
-  return {
-    kind,
-    label: kind === "weekly" ? "Weekly" : currentWindowLabel(window.limit_window_seconds, 5),
-    usedPercent,
-    resetsAt: codexResetAt(window, now)
-  };
-}
 function retryAfterMs(response, now) {
   const value = response.headers.get("retry-after")?.trim();
   if (!value) return void 0;
@@ -843,70 +990,6 @@ async function readUsageResponse(response, now) {
     throw new SubscriptionUsageError("Subscription usage response was not valid JSON");
   }
 }
-async function fetchAnthropicUsage(credentials, fetchFn, signal, now) {
-  const response = await fetchFn(ANTHROPIC_USAGE_URL, {
-    method: "GET",
-    signal,
-    headers: {
-      Authorization: `Bearer ${credentials.accessToken}`,
-      Accept: "application/json",
-      "anthropic-version": "2023-06-01",
-      "anthropic-beta": "oauth-2025-04-20",
-      "User-Agent": "ggcoder"
-    }
-  });
-  const data = await readUsageResponse(response, now());
-  const windows = [];
-  const currentPercent = clampPercent(data.five_hour?.utilization);
-  if (currentPercent !== void 0) {
-    windows.push({
-      kind: "current",
-      label: "5-hour",
-      usedPercent: currentPercent,
-      resetsAt: isoTimestamp(data.five_hour?.resets_at)
-    });
-  }
-  const weeklyPercent = clampPercent(data.seven_day?.utilization);
-  if (weeklyPercent !== void 0) {
-    windows.push({
-      kind: "weekly",
-      label: "Weekly",
-      usedPercent: weeklyPercent,
-      resetsAt: isoTimestamp(data.seven_day?.resets_at)
-    });
-  }
-  return {
-    provider: "anthropic",
-    displayName: "Anthropic",
-    windows,
-    fetchedAt: now()
-  };
-}
-async function fetchCodexUsage(credentials, fetchFn, signal, now) {
-  const headers = {
-    Authorization: `Bearer ${credentials.accessToken}`,
-    Accept: "application/json",
-    originator: "ggcoder",
-    "User-Agent": "ggcoder"
-  };
-  if (credentials.accountId) headers["ChatGPT-Account-Id"] = credentials.accountId;
-  const response = await fetchFn(CODEX_USAGE_URL, { method: "GET", signal, headers });
-  const data = await readUsageResponse(response, now());
-  const windows = [
-    normalizedCodexWindow(data.rate_limit?.primary_window, "current", now()),
-    normalizedCodexWindow(data.rate_limit?.secondary_window, "weekly", now())
-  ].filter((window) => window !== null);
-  windows.sort((left, right) => {
-    if (left.kind === right.kind) return 0;
-    return left.kind === "current" ? -1 : 1;
-  });
-  return {
-    provider: "openai",
-    displayName: "Codex",
-    windows,
-    fetchedAt: now()
-  };
-}
 function kimiNumber(value) {
   if (typeof value === "string" && value.trim()) {
     const parsed = Number(value);
@@ -937,15 +1020,14 @@ function kimiWindowMinutes(window) {
   }
 }
 async function fetchKimiUsage(credentials, fetchFn, signal, now) {
-  const response = await fetchFn(`${kimiCodeBaseUrl()}/usages`, {
+  const baseUrl = (credentials.baseUrl ?? KIMI_CODE_DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const response = await fetchFn(`${baseUrl}/usages`, {
     method: "GET",
     signal,
     headers: {
       Authorization: "Bearer " + credentials.accessToken,
       Accept: "application/json",
-      // The managed coding endpoint gates on the kimi-code-cli client identity,
-      // same as model requests.
-      ...kimiCodingHeaders()
+      "User-Agent": GG_CODER_USER_AGENT
     }
   });
   const data = await readUsageResponse(response, now());
@@ -997,7 +1079,7 @@ async function fetchSubscriptionUsage(provider, credentials, options = {}) {
   const now = options.now ?? Date.now;
   const signal = AbortSignal.timeout(options.timeoutMs ?? 8e3);
   try {
-    return provider === "anthropic" ? await fetchAnthropicUsage(credentials, fetchFn, signal, now) : provider === "openai" ? await fetchCodexUsage(credentials, fetchFn, signal, now) : await fetchKimiUsage(credentials, fetchFn, signal, now);
+    return await fetchKimiUsage(credentials, fetchFn, signal, now);
   } catch (error) {
     if (error instanceof SubscriptionUsageError) throw error;
     const message = error instanceof Error ? error.message : String(error);
@@ -1335,7 +1417,7 @@ async function transcribeVoice(fileUrl) {
 // src/auto-update.ts
 import { spawn } from "child_process";
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 1e4;
 function compareVersions(a, b) {
@@ -1377,7 +1459,7 @@ function createAutoUpdater(config) {
   function writeState(state) {
     try {
       const filePath = stateFilePath();
-      fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
+      fs.mkdirSync(path2.dirname(filePath), { recursive: true, mode: 448 });
       fs.writeFileSync(filePath, JSON.stringify(state));
     } catch {
     }
@@ -1503,34 +1585,55 @@ function createAutoUpdater(config) {
 export {
   AUTH_PROVIDERS,
   AuthStorage,
+  CHATGPT_PLAN_BASE_URL,
+  CHATGPT_PLAN_NOT_ENABLED_MESSAGE,
+  CHATGPT_PLAN_SCOPE,
+  CHATGPT_USAGE_URL,
+  CLAUDE_CODE_AUTH_KEY,
+  CLAUDE_CODE_AUTH_MARKER,
+  CLAUDE_CODE_MANIFEST,
+  ChatGPTPlanNotEnabledError,
   DEFAULT_LOCAL_ENDPOINTS,
   DEFAULT_MAX_VIDEO_BYTES,
   FALLBACK_CONTEXT_WINDOW,
   GEMINI_API_KEY,
   GEMINI_API_KEY_BASE_URL,
   HIDDEN_PROVIDERS,
+  KIMI_CODE_DEFAULT_BASE_URL,
+  KIMI_CODE_KEY,
+  KIMI_CODE_OVERSEAS_BASE_URL,
   LOCAL_API_KEY_PLACEHOLDER,
   LOCAL_AUTH_KEY_PREFIX,
   MINIMAX_CN_BASE_URL,
   MINIMAX_GLOBAL_BASE_URL,
   MODELS,
-  MOONSHOT_OAUTH_KEY,
   NotLoggedInError,
+  OPENAI_CHATGPT_KEY,
   OPENROUTER_DEFAULT_BASE_URL,
   PLAN_MODE_THINKING_CAP,
+  RETIRED_SIGN_INS,
   SubscriptionUsageError,
   TelegramBot,
-  XAI_OAUTH_KEY,
   XIAOMI_CREDITS_KEY,
   XIAOMI_TOKEN_PLAN_BASE_URLS,
+  apiKeyStorageKeys,
   authPriorityNote,
   clampThinkingForPlanMode,
+  claudeCodeAuthStatus,
+  claudeCodeBinaryPath,
+  claudeCodeCallbackUrl,
+  claudeCodeConfigDir,
+  claudeCodeEnv,
+  claudeCodeHome,
+  claudeCodePlatformKey,
+  clearClaudeCodeUsage,
   clearLocalDiscoveryCache,
   clearRuntimeModels,
   closeLogger,
   createAutoUpdater,
   decodeOggOpus,
   describeAuthMethods,
+  detectKimiCodeBaseUrl,
   detectMiniMaxBaseUrl,
   detectXiaomiTokenPlanBaseUrl,
   discoverLocalModels,
@@ -1538,8 +1641,11 @@ export {
   dualAuthProvider,
   dualAuthProviderByOAuthKey,
   endpointRoot,
+  ensureClaudeCodeBinary,
+  fetchChatGPTPlanModels,
   fetchSubscriptionUsage,
   findProbedModel,
+  formatClaudeCodeInstallProgress,
   formatLocalModelId,
   generatePKCE,
   getAllModels,
@@ -1547,8 +1653,7 @@ export {
   getAuthProvider,
   getAuthStorageKey,
   getAuthStorageKeys,
-  getClaudeCliUserAgent,
-  getClaudeCodeVersion,
+  getChatGPTHostId,
   getContextWindow,
   getDefaultModel,
   getDefaultThinkingLevel,
@@ -1564,48 +1669,49 @@ export {
   getSupportedThinkingLevels,
   getToolResultCharLimit,
   getVideoByteLimit,
-  grokCliBaseUrl,
-  grokCliHeaders,
-  isGrokCliEndpoint,
+  isClaudeCodeAuthMarker,
   isHiddenProvider,
   isKimiCodingEndpoint,
+  isLegacyClaudeOAuth,
   isLocalModelId,
   isLoggerOpen,
   isModelLoaded,
   isPaidModel,
   isThinkingLevelSupported,
-  kimiCodeBaseUrl,
-  kimiCodingHeaders,
   localAuthStorageKey,
   localModelShortName,
   log,
-  loginAnthropic,
-  loginGemini,
-  loginKimi,
-  loginOpenAI,
-  loginXai,
+  loginChatGPT,
+  loginClaudeCode,
+  logoutClaudeCode,
+  mergeClaudeCodeRateLimit,
   oauthStorageKey,
   ollamaServedContext,
   openLog,
+  parseCallbackInput,
   parseLocalModelId,
   parseOpenRouterCatalog,
-  pendingClaudeCodeVersionRefresh,
   probeEndpoint,
   providerStorageKeys,
+  readClaudeCodeUsage,
   readStoredBaseUrlSync,
-  refreshAnthropicToken,
-  refreshGeminiToken,
-  refreshKimiToken,
-  refreshOpenAIToken,
-  refreshXaiToken,
+  recordClaudeCodeRateLimit,
+  refreshChatGPTToken,
   registerLogCleanup,
   registerRuntimeModels,
+  requiredKeyLabel,
   resample,
+  resolveClaudeCodeBinary,
+  revokeChatGPTSignIn,
   setProgressCallback,
   setProviderCatalog,
+  signInWithClaudeCode,
+  signOutOfClaudeCode,
+  storageKeyProvider,
   toModelInfo,
   transcribeVoice,
   usesOpenAICodexTransport,
+  verifyIdToken,
   withFileLock,
   withoutPaidTier
 };