@prestyj/core 5.3.1 → 5.4.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,
@@ -1535,49 +1537,63 @@ var MODELS = [
     maxThinkingLevel: "high"
   },
   // ── OpenAI (Codex) ─────────────────────────────────────
+  // GPT-5.6 family — three agentic coding tiers launched July 2026. All share a
+  // 372K context window: the Codex repo's models.json lists both `context_window`
+  // AND `max_context_window` as 372000 for every 5.6 variant, so (unlike 5.4/5.5,
+  // whose public-API 1M window exceeds the Codex-product cap) there's no split
+  // between the API and Codex-transport windows — a single `contextWindow` is
+  // correct in both code paths. All three take text+image input, freeform
+  // apply_patch, text+image web search, and parallel tool calls.
   {
-    id: "gpt-5.5",
-    name: "GPT-5.5",
+    // Sol — "Latest frontier agentic coding model." (priority 1, default low).
+    // Reasoning ladder: low → medium → high → xhigh → max → ultra. gg-ai's
+    // ThinkingLevel tops out at `max`, so that's the cap here; the `ultra` rung
+    // (auto task delegation) needs a ThinkingLevel extension to expose.
+    id: "gpt-5.6-sol",
+    name: "GPT-5.6 Sol",
     provider: "openai",
-    contextWindow: 105e4,
-    codexContextWindow: 272e3,
+    contextWindow: 372e3,
     maxOutputTokens: 128e3,
     supportsThinking: true,
     supportsImages: true,
     supportsVideo: false,
     costTier: "high",
-    maxThinkingLevel: "xhigh"
+    maxThinkingLevel: "max"
   },
   {
-    id: "gpt-5.4",
-    name: "GPT-5.4",
+    // Terra — "Balanced agentic coding model for everyday work." (priority 2,
+    // default medium). Same 372K context + ultra reasoning ladder as Sol.
+    id: "gpt-5.6-terra",
+    name: "GPT-5.6 Terra",
     provider: "openai",
-    contextWindow: 105e4,
-    codexContextWindow: 272e3,
+    contextWindow: 372e3,
     maxOutputTokens: 128e3,
     supportsThinking: true,
     supportsImages: true,
     supportsVideo: false,
-    costTier: "high",
-    maxThinkingLevel: "xhigh"
+    costTier: "medium",
+    maxThinkingLevel: "max"
   },
   {
-    id: "gpt-5.4-mini",
-    name: "GPT-5.4 Mini",
+    // Luna — "Fast and affordable agentic coding model." (priority 3, default
+    // medium). Same 372K context; reasoning tops out at `max` (no `ultra` rung).
+    id: "gpt-5.6-luna",
+    name: "GPT-5.6 Luna",
     provider: "openai",
-    contextWindow: 4e5,
+    contextWindow: 372e3,
     maxOutputTokens: 128e3,
     supportsThinking: true,
     supportsImages: true,
     supportsVideo: false,
     costTier: "low",
-    maxThinkingLevel: "xhigh"
+    maxThinkingLevel: "max"
   },
   {
-    id: "gpt-5.3-codex",
-    name: "GPT-5.3 Codex",
+    id: "gpt-5.5",
+    name: "GPT-5.5",
     provider: "openai",
-    contextWindow: 4e5,
+    contextWindow: 105e4,
+    codexContextWindow: 272e3,
     maxOutputTokens: 128e3,
     supportsThinking: true,
     supportsImages: true,
@@ -1617,8 +1633,8 @@ var MODELS = [
   },
   // ── Gemini ─────────────────────────────────────────────
   {
-    id: "gemini-3.1-flash-lite-preview",
-    name: "Gemini 3.1 Flash Lite Preview",
+    id: "gemini-3.1-flash-lite",
+    name: "Gemini 3.1 Flash Lite",
     provider: "gemini",
     contextWindow: 1048576,
     maxOutputTokens: 65536,
@@ -1630,7 +1646,10 @@ var MODELS = [
     maxThinkingLevel: "high"
   },
   {
-    id: "gemini-3.5-flash",
+    // Wire name `gemini-3-flash` — the Code Assist (OAuth) backend rejects the
+    // display string `gemini-3.5-flash` with a 404, so gemini-cli keeps this
+    // alternative name (SECONDARY_GEMINI_3_5_FLASH_MODEL) for that endpoint.
+    id: "gemini-3-flash",
     name: "Gemini 3.5 Flash",
     provider: "gemini",
     contextWindow: 1048576,
@@ -1642,6 +1661,22 @@ var MODELS = [
     costTier: "low",
     maxThinkingLevel: "high"
   },
+  {
+    // Gemini 3.1 Pro is public preview — gated behind Code Assist preview
+    // enablement, so free/personal OAuth accounts 404 on it (see
+    // ACCOUNT_GATED_MODELS in gg-ai's gemini provider).
+    id: "gemini-3.1-pro-preview",
+    name: "Gemini 3.1 Pro (Preview)",
+    provider: "gemini",
+    contextWindow: 1048576,
+    maxOutputTokens: 65536,
+    supportsThinking: true,
+    supportsImages: true,
+    supportsVideo: true,
+    maxVideoBytes: 20 * 1024 * 1024,
+    costTier: "high",
+    maxThinkingLevel: "high"
+  },
   // ── Moonshot (Kimi) ────────────────────────────────────
   {
     id: "kimi-k2.7-code",
@@ -1832,8 +1867,8 @@ function getVideoByteLimit(modelId) {
 }
 function getDefaultModel(provider) {
   if (provider === "xiaomi") return MODELS.find((m) => m.id === "mimo-v2.5-pro");
-  if (provider === "openai") return MODELS.find((m) => m.id === "gpt-5.5");
-  if (provider === "gemini") return MODELS.find((m) => m.id === "gemini-3.1-flash-lite-preview");
+  if (provider === "openai") return MODELS.find((m) => m.id === "gpt-5.6-sol");
+  if (provider === "gemini") return MODELS.find((m) => m.id === "gemini-3.1-flash-lite");
   if (provider === "glm") return MODELS.find((m) => m.id === "glm-5.2");
   if (provider === "moonshot") return MODELS.find((m) => m.id === "kimi-k2.7-code");
   if (provider === "minimax") return MODELS.find((m) => m.id === "MiniMax-M3");
@@ -1873,6 +1908,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",
@@ -1902,10 +1944,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);
@@ -1913,9 +1955,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);
@@ -1932,6 +1975,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": "ezcoder"
+    }
+  });
+  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: "ezcoder",
+    "User-Agent": "ezcoder"
+  };
+  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;
@@ -2414,12 +2598,14 @@ function createAutoUpdater(config) {
   MODELS,
   MOONSHOT_OAUTH_KEY,
   NotLoggedInError,
+  SubscriptionUsageError,
   TelegramBot,
   XIAOMI_CREDITS_KEY,
   closeLogger,
   createAutoUpdater,
   decodeOggOpus,
   downmixToMono,
+  fetchSubscriptionUsage,
   generatePKCE,
   getAppPaths,
   getAuthStorageKey,