@kenkaiiii/gg-core 5.9.6 → 5.10.0

package/dist/index.cjs

@@ -35,12 +35,14 @@ __export(index_exports, {
   MODELS: () => MODELS,
   MOONSHOT_OAUTH_KEY: () => MOONSHOT_OAUTH_KEY,
   NotLoggedInError: () => NotLoggedInError,
+  SubscriptionUsageError: () => SubscriptionUsageError,
   TelegramBot: () => TelegramBot,
   XIAOMI_CREDITS_KEY: () => XIAOMI_CREDITS_KEY,
   closeLogger: () => closeLogger,
   createAutoUpdater: () => createAutoUpdater,
   decodeOggOpus: () => decodeOggOpus,
   downmixToMono: () => downmixToMono,
+  fetchSubscriptionUsage: () => fetchSubscriptionUsage,
   generatePKCE: () => generatePKCE,
   getAppPaths: () => getAppPaths,
   getAuthStorageKey: () => getAuthStorageKey,
@@ -1895,6 +1897,13 @@ function getFastModel(provider, currentModelId) {
 
 // src/thinking-level.ts
 var OPENAI_GPT_THINKING_LEVELS = ["medium", "high", "xhigh"];
+var OPENAI_GPT_56_THINKING_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
 var SAKANA_THINKING_LEVELS = ["high", "xhigh"];
 var ANTHROPIC_OPUS_48_47_THINKING_LEVELS = [
   "low",
@@ -1924,10 +1933,10 @@ function isAnthropicAdaptiveModel(provider, model) {
 function getSupportedThinkingLevels(provider, model) {
   const maxLevel = getMaxThinkingLevel(model);
   if (isAnthropicAdaptiveModel(provider, model)) {
-    const levels = isAnthropicOpus48Or47Model(provider, model) ? ANTHROPIC_OPUS_48_47_THINKING_LEVELS : ANTHROPIC_ADAPTIVE_THINKING_LEVELS;
-    const maxIndex2 = levels.indexOf(maxLevel);
+    const levels2 = isAnthropicOpus48Or47Model(provider, model) ? ANTHROPIC_OPUS_48_47_THINKING_LEVELS : ANTHROPIC_ADAPTIVE_THINKING_LEVELS;
+    const maxIndex2 = levels2.indexOf(maxLevel);
     if (maxIndex2 === -1) return ["low", "medium", "high"];
-    return levels.slice(0, maxIndex2 + 1);
+    return levels2.slice(0, maxIndex2 + 1);
   }
   if (isSakanaModel(provider)) {
     const maxIndex2 = SAKANA_THINKING_LEVELS.indexOf(maxLevel);
@@ -1935,9 +1944,10 @@ function getSupportedThinkingLevels(provider, model) {
     return SAKANA_THINKING_LEVELS.slice(0, maxIndex2 + 1);
   }
   if (!isOpenAIGptModel(provider, model)) return [maxLevel];
-  const maxIndex = OPENAI_GPT_THINKING_LEVELS.indexOf(maxLevel);
+  const levels = model.startsWith("gpt-5.6-") ? OPENAI_GPT_56_THINKING_LEVELS : OPENAI_GPT_THINKING_LEVELS;
+  const maxIndex = levels.indexOf(maxLevel);
   if (maxIndex === -1) return ["medium"];
-  return OPENAI_GPT_THINKING_LEVELS.slice(0, maxIndex + 1);
+  return levels.slice(0, maxIndex + 1);
 }
 function isThinkingLevelSupported(provider, model, level) {
   return getSupportedThinkingLevels(provider, model).includes(level);
@@ -1954,6 +1964,147 @@ function getNextThinkingLevel(provider, model, current) {
   return supportedLevels[index + 1];
 }
 
+// src/provider-usage.ts
+var SubscriptionUsageError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    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`;
+}
+async function readUsageResponse(response) {
+  const text = await response.text();
+  if (!response.ok) {
+    throw new SubscriptionUsageError(
+      `Subscription usage request failed with HTTP ${response.status}`,
+      response.status
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    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);
+  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);
+  const windows = [];
+  const current = data.rate_limit?.primary_window;
+  const currentPercent = clampPercent(current?.used_percent);
+  if (current && currentPercent !== void 0) {
+    windows.push({
+      kind: "current",
+      label: currentWindowLabel(current.limit_window_seconds, 5),
+      usedPercent: currentPercent,
+      resetsAt: codexResetAt(current, now())
+    });
+  }
+  const weekly = data.rate_limit?.secondary_window;
+  const weeklyPercent = clampPercent(weekly?.used_percent);
+  if (weekly && weeklyPercent !== void 0) {
+    windows.push({
+      kind: "weekly",
+      label: "Weekly",
+      usedPercent: weeklyPercent,
+      resetsAt: codexResetAt(weekly, now())
+    });
+  }
+  return {
+    provider: "openai",
+    displayName: "Codex",
+    windows,
+    fetchedAt: now()
+  };
+}
+async function fetchSubscriptionUsage(provider, credentials, options = {}) {
+  const fetchFn = options.fetchFn ?? fetch;
+  const now = options.now ?? Date.now;
+  const signal = AbortSignal.timeout(options.timeoutMs ?? 8e3);
+  try {
+    return provider === "anthropic" ? await fetchAnthropicUsage(credentials, fetchFn, signal, now) : await fetchCodexUsage(credentials, fetchFn, signal, now);
+  } catch (error) {
+    if (error instanceof SubscriptionUsageError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new SubscriptionUsageError(message);
+  }
+}
+
 // src/telegram.ts
 var TELEGRAM_API = "https://api.telegram.org";
 var MAX_MESSAGE_LENGTH = 4096;
@@ -2436,12 +2587,14 @@ function createAutoUpdater(config) {
   MODELS,
   MOONSHOT_OAUTH_KEY,
   NotLoggedInError,
+  SubscriptionUsageError,
   TelegramBot,
   XIAOMI_CREDITS_KEY,
   closeLogger,
   createAutoUpdater,
   decodeOggOpus,
   downmixToMono,
+  fetchSubscriptionUsage,
   generatePKCE,
   getAppPaths,
   getAuthStorageKey,