zelari-code 1.37.0 → 1.41.0

package/dist/cli/main.bundled.js

@@ -794,16 +794,19 @@ __export(chatgptOAuth_exports, {
   CHATGPT_DEVICE_CODE_URL: () => CHATGPT_DEVICE_CODE_URL,
   CHATGPT_DEVICE_REDIRECT_URI: () => CHATGPT_DEVICE_REDIRECT_URI,
   CHATGPT_DEVICE_TOKEN_URL: () => CHATGPT_DEVICE_TOKEN_URL,
+  CHATGPT_DEVICE_VERIFY_URL: () => CHATGPT_DEVICE_VERIFY_URL,
   CHATGPT_SCOPE: () => CHATGPT_SCOPE,
   CHATGPT_TOKEN_URL: () => CHATGPT_TOKEN_URL,
   ChatgptOAuthError: () => ChatgptOAuthError,
   DEFAULT_CHATGPT_CLIENT_ID: () => DEFAULT_CHATGPT_CLIENT_ID,
   decodeJwtClaims: () => decodeJwtClaims,
   extractChatgptAccountId: () => extractChatgptAccountId,
+  pollChatgptDeviceAuth: () => pollChatgptDeviceAuth,
   refreshChatgptToken: () => refreshChatgptToken,
   runChatgptBrowserFlow: () => runChatgptBrowserFlow,
   runChatgptDeviceFlow: () => runChatgptDeviceFlow,
-  runChatgptOAuthFlow: () => runChatgptOAuthFlow
+  runChatgptOAuthFlow: () => runChatgptOAuthFlow,
+  startChatgptDeviceAuth: () => startChatgptDeviceAuth
 });
 function decodeJwtClaims(token) {
   const parts = token.split(".");
@@ -845,6 +848,29 @@ function parseTokenPayload(obj, fallbackRefresh) {
   }
   return result;
 }
+function errorSnippet(body) {
+  const err = body.error;
+  if (typeof err === "string" && err.trim()) return err.trim().slice(0, 160);
+  if (err && typeof err === "object") {
+    const msg2 = err.message;
+    if (typeof msg2 === "string" && msg2.trim()) return msg2.trim().slice(0, 160);
+  }
+  const msg = body.message;
+  if (typeof msg === "string" && msg.trim()) return msg.trim().slice(0, 160);
+  return "";
+}
+function formatHttpError(prefix, status, body) {
+  const detail = errorSnippet(body);
+  return detail ? `${prefix} HTTP ${status}: ${detail}` : `${prefix} HTTP ${status}`;
+}
+async function readJsonBody(response) {
+  try {
+    const parsed = await response.json();
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return {};
+}
 async function postForm(url2, data, fetchImpl) {
   let response;
   try {
@@ -862,13 +888,34 @@ async function postForm(url2, data, fetchImpl) {
       "network_error"
     );
   }
-  let body = {};
+  return { status: response.status, body: await readJsonBody(response) };
+}
+async function postJson(url2, data, fetchImpl) {
+  let response;
   try {
-    const parsed = await response.json();
-    if (parsed && typeof parsed === "object") body = parsed;
-  } catch {
+    response = await fetchImpl(url2, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(data)
+    });
+  } catch (err) {
+    throw new ChatgptOAuthError(
+      `ChatGPT OAuth network error: ${err instanceof Error ? err.message : String(err)}`,
+      "network_error"
+    );
   }
-  return { status: response.status, body };
+  return { status: response.status, body: await readJsonBody(response) };
+}
+function parsePollInterval(raw, fallback = 5) {
+  if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) return raw;
+  if (typeof raw === "string") {
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return fallback;
 }
 async function refreshChatgptToken(options) {
   if (!options.refreshToken.trim()) {
@@ -887,77 +934,82 @@ async function refreshChatgptToken(options) {
   );
   if (status >= 400) {
     const code = status === 400 || status === 401 ? "invalid_grant" : `http_${status}`;
-    throw new ChatgptOAuthError(
-      `ChatGPT token refresh HTTP ${status}: ${String(body.error ?? "").slice(0, 160)}`,
-      code
-    );
+    throw new ChatgptOAuthError(formatHttpError("ChatGPT token refresh", status, body), code);
   }
   return parseTokenPayload(body, options.refreshToken);
 }
-async function runChatgptDeviceFlow(options) {
+async function startChatgptDeviceAuth(options = {}) {
   const clientId2 = options.clientId || process.env.CHATGPT_OAUTH_CLIENT_ID || DEFAULT_CHATGPT_CLIENT_ID;
   const fetchImpl = options.fetchImpl ?? fetch;
-  const sleep = options.sleepImpl ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const { verifier, challenge } = generatePkcePair();
-  const start = await postForm(
-    CHATGPT_DEVICE_CODE_URL,
-    {
-      client_id: clientId2,
-      scope: CHATGPT_SCOPE,
-      code_challenge: challenge,
-      code_challenge_method: "S256"
-    },
-    fetchImpl
-  );
+  const start = await postJson(CHATGPT_DEVICE_CODE_URL, { client_id: clientId2 }, fetchImpl);
   if (start.status >= 400) {
     throw new ChatgptOAuthError(
-      `ChatGPT device-code HTTP ${start.status}`,
+      formatHttpError("ChatGPT device-code", start.status, start.body),
       `device_http_${start.status}`
     );
   }
-  const deviceCode = start.body.device_code;
-  const userCode = start.body.user_code;
-  const verificationUri = typeof start.body.verification_uri === "string" && start.body.verification_uri || typeof start.body.verification_uri_complete === "string" && start.body.verification_uri_complete;
-  if (typeof deviceCode !== "string" || typeof userCode !== "string" || typeof verificationUri !== "string") {
+  const deviceAuthId = typeof start.body.device_auth_id === "string" && start.body.device_auth_id || typeof start.body.device_code === "string" && start.body.device_code || "";
+  const userCode = typeof start.body.user_code === "string" && start.body.user_code || typeof start.body.usercode === "string" && start.body.usercode || "";
+  const verificationUri = typeof start.body.verification_uri === "string" && start.body.verification_uri || typeof start.body.verification_url === "string" && start.body.verification_url || `${CHATGPT_DEVICE_VERIFY_URL}?user_code=${encodeURIComponent(userCode)}`;
+  if (!deviceAuthId || !userCode) {
     throw new ChatgptOAuthError("Device-code response missing fields", "no_device_code");
   }
-  const info = {
+  return {
+    deviceAuthId,
     userCode,
     verificationUri,
+    interval: parsePollInterval(start.body.interval, 5),
     ...typeof start.body.verification_uri_complete === "string" ? { verificationUriComplete: start.body.verification_uri_complete } : {}
   };
-  if (options.onUserCode) await options.onUserCode(info);
-  try {
-    await (options.openBrowserImpl ?? openBrowser)(
-      info.verificationUriComplete ?? info.verificationUri
-    );
-  } catch {
-  }
+}
+async function pollChatgptDeviceAuth(options) {
+  const clientId2 = options.clientId || process.env.CHATGPT_OAUTH_CLIENT_ID || DEFAULT_CHATGPT_CLIENT_ID;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const sleep = options.sleepImpl ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const timeoutMs = options.timeoutMs ?? 3e5;
   const deadline = Date.now() + timeoutMs;
-  let interval = 5;
+  let interval = options.interval ?? 5;
   let authorizationCode;
+  let codeVerifier;
   while (Date.now() < deadline) {
-    const poll = await postForm(
+    const poll = await postJson(
       CHATGPT_DEVICE_TOKEN_URL,
-      { client_id: clientId2, device_code: deviceCode },
+      { device_auth_id: options.deviceAuthId, user_code: options.userCode },
       fetchImpl
     );
     const authCode = poll.body.authorization_code;
     if (typeof authCode === "string" && authCode.length > 0) {
       authorizationCode = authCode;
+      if (typeof poll.body.code_verifier === "string" && poll.body.code_verifier) {
+        codeVerifier = poll.body.code_verifier;
+      }
       break;
     }
+    if (poll.status === 403 || poll.status === 404) {
+      await sleep(interval * 1e3);
+      continue;
+    }
     const err = typeof poll.body.error === "string" ? poll.body.error : "";
     if (err === "slow_down") interval += 5;
     else if (err && err !== "authorization_pending") {
       throw new ChatgptOAuthError(`Device authorization failed: ${err}`, err);
+    } else if (poll.status >= 400) {
+      throw new ChatgptOAuthError(
+        formatHttpError("ChatGPT device poll", poll.status, poll.body),
+        `poll_http_${poll.status}`
+      );
     }
     await sleep(interval * 1e3);
   }
   if (!authorizationCode) {
     throw new ChatgptOAuthError("Timed out waiting for ChatGPT device authorization", "timeout");
   }
+  if (!codeVerifier) {
+    throw new ChatgptOAuthError(
+      "Device token response missing code_verifier (server-issued PKCE)",
+      "no_code_verifier"
+    );
+  }
   const token = await postForm(
     CHATGPT_TOKEN_URL,
     {
@@ -965,13 +1017,13 @@ async function runChatgptDeviceFlow(options) {
       code: authorizationCode,
       redirect_uri: CHATGPT_DEVICE_REDIRECT_URI,
       client_id: clientId2,
-      code_verifier: verifier
+      code_verifier: codeVerifier
     },
     fetchImpl
   );
   if (token.status >= 400) {
     throw new ChatgptOAuthError(
-      `ChatGPT token exchange HTTP ${token.status}`,
+      formatHttpError("ChatGPT token exchange", token.status, token.body),
       `token_http_${token.status}`
     );
   }
@@ -1024,12 +1076,47 @@ async function runChatgptBrowserFlow(options) {
   );
   if (token.status >= 400) {
     throw new ChatgptOAuthError(
-      `ChatGPT token exchange HTTP ${token.status}`,
+      formatHttpError("ChatGPT token exchange", token.status, token.body),
       `token_http_${token.status}`
     );
   }
   return parseTokenPayload(token.body);
 }
+async function runChatgptDeviceFlow(options = {}) {
+  const session = await startChatgptDeviceAuth({
+    clientId: options.clientId,
+    fetchImpl: options.fetchImpl
+  });
+  const info = {
+    userCode: session.userCode,
+    verificationUri: session.verificationUri,
+    ...session.verificationUriComplete ? { verificationUriComplete: session.verificationUriComplete } : {}
+  };
+  if (options.onUserCode) {
+    await options.onUserCode(info);
+  } else {
+    process.stderr.write(
+      `[chatgpt oauth] Open ${info.verificationUri} and enter:
+  ${info.userCode}
+`
+    );
+  }
+  try {
+    await (options.openBrowserImpl ?? openBrowser)(
+      info.verificationUriComplete ?? info.verificationUri
+    );
+  } catch {
+  }
+  return pollChatgptDeviceAuth({
+    deviceAuthId: session.deviceAuthId,
+    userCode: session.userCode,
+    clientId: options.clientId,
+    interval: session.interval,
+    fetchImpl: options.fetchImpl,
+    sleepImpl: options.sleepImpl,
+    timeoutMs: options.timeoutMs
+  });
+}
 async function runChatgptOAuthFlow(options = {}) {
   const flow = (process.env.CHATGPT_OAUTH_FLOW ?? "device").toLowerCase();
   if (flow === "browser") {
@@ -1037,7 +1124,7 @@ async function runChatgptOAuthFlow(options = {}) {
   }
   return runChatgptDeviceFlow(options);
 }
-var DEFAULT_CHATGPT_CLIENT_ID, CHATGPT_AUTHORIZE_URL, CHATGPT_TOKEN_URL, CHATGPT_DEVICE_CODE_URL, CHATGPT_DEVICE_TOKEN_URL, CHATGPT_DEVICE_REDIRECT_URI, CHATGPT_SCOPE, CHATGPT_AUTH_CLAIMS, ChatgptOAuthError;
+var DEFAULT_CHATGPT_CLIENT_ID, CHATGPT_AUTHORIZE_URL, CHATGPT_TOKEN_URL, CHATGPT_DEVICE_CODE_URL, CHATGPT_DEVICE_TOKEN_URL, CHATGPT_DEVICE_REDIRECT_URI, CHATGPT_DEVICE_VERIFY_URL, CHATGPT_SCOPE, CHATGPT_AUTH_CLAIMS, ChatgptOAuthError;
 var init_chatgptOAuth = __esm({
   "src/cli/chatgptOAuth.ts"() {
     "use strict";
@@ -1049,6 +1136,7 @@ var init_chatgptOAuth = __esm({
     CHATGPT_DEVICE_CODE_URL = "https://auth.openai.com/api/accounts/deviceauth/usercode";
     CHATGPT_DEVICE_TOKEN_URL = "https://auth.openai.com/api/accounts/deviceauth/token";
     CHATGPT_DEVICE_REDIRECT_URI = "https://auth.openai.com/deviceauth/callback";
+    CHATGPT_DEVICE_VERIFY_URL = "https://auth.openai.com/codex/device";
     CHATGPT_SCOPE = "openid profile email offline_access";
     CHATGPT_AUTH_CLAIMS = "https://api.openai.com/auth";
     ChatgptOAuthError = class extends Error {
@@ -1152,7 +1240,7 @@ async function startAnthropicOAuth(options = {}) {
   }
   return { authorizeUrl, state: state3 };
 }
-async function postJson(url2, payload, fetchImpl) {
+async function postJson2(url2, payload, fetchImpl) {
   let response;
   try {
     response = await fetchImpl(url2, {
@@ -1212,7 +1300,7 @@ async function completeAnthropicOAuth(options) {
     redirect_uri: ANTHROPIC_REDIRECT_URI,
     state: parsed.state ?? pending.state
   };
-  const { status, body } = await postJson(ANTHROPIC_TOKEN_URL, payload, fetchImpl);
+  const { status, body } = await postJson2(ANTHROPIC_TOKEN_URL, payload, fetchImpl);
   if (status >= 400) {
     const code = status === 400 || status === 401 ? "invalid_grant" : `http_${status}`;
     throw new AnthropicOAuthError(
@@ -1227,7 +1315,7 @@ async function refreshAnthropicToken(options) {
     throw new AnthropicOAuthError("Missing refreshToken", "no_refresh_token");
   }
   const fetchImpl = options.fetchImpl ?? fetch;
-  const { status, body } = await postJson(
+  const { status, body } = await postJson2(
     ANTHROPIC_TOKEN_URL,
     {
       grant_type: "refresh_token",
@@ -1532,9 +1620,151 @@ var init_keyStore = __esm({
   }
 });
 
+// src/cli/thinkingCapability.ts
+function thinkingCapabilityFor(id, model) {
+  const base = PROVIDER_THINKING_CAPABILITY[id] ?? {};
+  const efforts = effortLevelsFor(id, model);
+  const budget = supportsBudget(id, model);
+  return {
+    ...base,
+    effort: efforts.length > 0 || Boolean(base.effort),
+    budget,
+    efforts: efforts.length > 0 ? efforts : void 0
+  };
+}
+function effortLevelsFor(id, model) {
+  const m = (model ?? "").trim();
+  switch (id) {
+    case "grok":
+    case "openai-compatible":
+    case "custom":
+      if (grokHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
+      return [...BASE_EFFORTS];
+    case "chatgpt":
+      if (gptHasMax(m)) return [...BASE_EFFORTS, "xhigh", "max"];
+      if (gptHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
+      return [...BASE_EFFORTS];
+    case "deepseek":
+      return ["high", "max"];
+    case "minimax":
+      return [...BASE_EFFORTS];
+    case "glm":
+      if (glmHasEffortScale(m)) return ["low", "high", "max"];
+      return [];
+    case "anthropic":
+      if (claudeHasXhigh(m)) return ["high", "xhigh", "max"];
+      if (claudeHasMax(m)) return ["high", "max"];
+      return [];
+    default:
+      return [];
+  }
+}
+function supportsBudget(id, model) {
+  if (id === "anthropic") return true;
+  if (id === "glm") return !glmHasEffortScale(model);
+  return Boolean(PROVIDER_THINKING_CAPABILITY[id]?.budget);
+}
+function grokHasXhigh(model) {
+  const v = parseDottedVersion(model, /grok[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major > 4 || v.major === 4 && v.minor >= 6;
+}
+function gptHasXhigh(model) {
+  const v = parseDottedVersion(model, /gpt[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major > 5 || v.major === 5 && v.minor >= 4;
+}
+function gptHasMax(model) {
+  const v = parseDottedVersion(model, /gpt[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major > 5 || v.major === 5 && v.minor >= 6;
+}
+function claudeHasMax(model) {
+  const v = parseClaudeVersion(model);
+  if (!v) return false;
+  return v.major > 4 || v.major === 4 && v.minor >= 6;
+}
+function claudeHasXhigh(model) {
+  const v = parseClaudeVersion(model);
+  if (!v) return false;
+  if (v.major >= 5) return true;
+  return v.major === 4 && v.minor >= 7;
+}
+function glmHasEffortScale(model) {
+  const v = parseDottedVersion(model ?? "", /glm[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major >= 5;
+}
+function parseDottedVersion(model, re) {
+  const m = re.exec(model);
+  if (!m) return null;
+  return {
+    major: Number.parseInt(m[1], 10),
+    minor: m[2] ? Number.parseInt(m[2], 10) : 0
+  };
+}
+function parseClaudeVersion(model) {
+  const m = /claude-(?:sonnet|opus|haiku)[-_]?(\d+)(?:[.-](\d+))?/i.exec(model);
+  if (!m) return null;
+  return {
+    major: Number.parseInt(m[1], 10),
+    minor: m[2] ? Number.parseInt(m[2], 10) : 0
+  };
+}
+var THINKING_EFFORTS, BASE_EFFORTS, PROVIDER_THINKING_CAPABILITY;
+var init_thinkingCapability = __esm({
+  "src/cli/thinkingCapability.ts"() {
+    "use strict";
+    THINKING_EFFORTS = [
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ];
+    BASE_EFFORTS = ["low", "medium", "high"];
+    PROVIDER_THINKING_CAPABILITY = {
+      "openai-compatible": { effort: true },
+      grok: { effort: true },
+      chatgpt: { effort: true },
+      anthropic: { budget: true },
+      glm: { budget: true },
+      deepseek: { effort: true },
+      minimax: { effort: true },
+      custom: { effort: true }
+    };
+  }
+});
+
 // src/cli/thinking.ts
-function thinkingCapabilityFor(id) {
-  return PROVIDER_THINKING_CAPABILITY[id] ?? {};
+function clampEffort(id, model, requested) {
+  const native = effortLevelsFor(id, model);
+  if (native.includes(requested)) {
+    return { effort: requested, clamped: false };
+  }
+  if (native.length === 0) {
+    return {
+      effort: requested,
+      clamped: true,
+      note: `thinking '${requested}' is not supported for provider "${id}"`
+    };
+  }
+  const want = EFFORT_RANK[requested];
+  let best = native[0];
+  let bestDist = Math.abs(EFFORT_RANK[best] - want);
+  for (const level of native) {
+    const dist = Math.abs(EFFORT_RANK[level] - want);
+    if (dist < bestDist || dist === bestDist && EFFORT_RANK[level] > EFFORT_RANK[best]) {
+      best = level;
+      bestDist = dist;
+    }
+  }
+  const label = model ? `${id}/${model}` : id;
+  return {
+    effort: best,
+    clamped: true,
+    note: `'${requested}' is not native on ${label} \u2014 using '${best}'`
+  };
 }
 function stringifyThinkingSpec(spec) {
   if (spec === "auto") return "auto";
@@ -1546,7 +1776,9 @@ function parseThinkingSpec(raw) {
   const s = (raw ?? "").trim().toLowerCase();
   if (!s || s === "auto") return "auto";
   if (s === "off") return { kind: "off" };
-  if (s === "low" || s === "medium" || s === "high") return { kind: "effort", effort: s };
+  if (THINKING_EFFORTS.includes(s)) {
+    return { kind: "effort", effort: s };
+  }
   const m = /^budget:(\d+)$/.exec(s);
   if (m) {
     const n = Number.parseInt(m[1], 10);
@@ -1556,15 +1788,19 @@ function parseThinkingSpec(raw) {
 }
 function isValidThinkingInput(raw) {
   const s = raw.trim().toLowerCase();
-  if (s === "auto" || s === "off" || s === "low" || s === "medium" || s === "high") return true;
+  if (s === "auto" || s === "off") return true;
+  if (THINKING_EFFORTS.includes(s)) return true;
   return /^budget:\d+$/.test(s) && Number.parseInt(s.slice(7), 10) > 0;
 }
 function degrade(note) {
   return { patch: {}, degraded: true, note };
 }
-function translateOpenAiCompatibleThinking(providerId, spec) {
+function withClampNote(patch, clamped, note) {
+  return { patch, degraded: false, note: clamped ? note : void 0 };
+}
+function translateOpenAiCompatibleThinking(providerId, spec, model) {
   if (spec === "auto") return { patch: {}, degraded: false };
-  const cap3 = thinkingCapabilityFor(providerId);
+  const cap3 = thinkingCapabilityFor(providerId, model);
   switch (spec.kind) {
     case "off":
       if (providerId === "deepseek" || providerId === "glm") {
@@ -1572,20 +1808,40 @@ function translateOpenAiCompatibleThinking(providerId, spec) {
       }
       if (cap3.effort) return { patch: { reasoning_effort: "low" }, degraded: false };
       return degrade(`thinking 'off' is not supported for provider "${providerId}"`);
-    case "effort":
-      if (!cap3.effort) {
+    case "effort": {
+      if (!cap3.effort && !cap3.efforts?.length) {
         return degrade(`thinking 'effort' is not supported for provider "${providerId}"`);
       }
+      const resolved = clampEffort(providerId, model, spec.effort);
       if (providerId === "deepseek") {
-        return {
-          patch: {
+        return withClampNote(
+          {
             thinking: { type: "enabled" },
-            reasoning_effort: spec.effort === "high" ? "max" : "high"
+            reasoning_effort: resolved.effort === "max" ? "max" : "high"
           },
-          degraded: false
-        };
+          resolved.clamped,
+          resolved.note
+        );
       }
-      return { patch: { reasoning_effort: spec.effort }, degraded: false };
+      if (providerId === "glm") {
+        if (!glmHasEffortScale(model)) {
+          return degrade(`thinking 'effort' is not supported for GLM ${model || "4.x"} \u2014 use budget:N`);
+        }
+        return withClampNote(
+          {
+            thinking: { type: "enabled" },
+            reasoning_effort: resolved.effort
+          },
+          resolved.clamped,
+          resolved.note
+        );
+      }
+      return withClampNote(
+        { reasoning_effort: resolved.effort },
+        resolved.clamped,
+        resolved.note
+      );
+    }
     case "budget":
       if (!cap3.budget) {
         return degrade(`thinking 'budget' is not supported for provider "${providerId}"`);
@@ -1596,18 +1852,24 @@ function translateOpenAiCompatibleThinking(providerId, spec) {
       };
   }
 }
-function translateResponsesThinking(spec) {
+function translateResponsesThinking(spec, model) {
   if (spec === "auto") return { patch: {}, degraded: false };
   switch (spec.kind) {
     case "off":
       return { patch: { reasoning: { effort: "minimal" } }, degraded: false };
-    case "effort":
-      return { patch: { reasoning: { effort: spec.effort } }, degraded: false };
+    case "effort": {
+      const resolved = clampEffort("chatgpt", model, spec.effort);
+      return withClampNote(
+        { reasoning: { effort: resolved.effort } },
+        resolved.clamped,
+        resolved.note
+      );
+    }
     case "budget":
-      return degrade('thinking "budget" is not supported for chatgpt \u2014 use low/medium/high');
+      return degrade('thinking "budget" is not supported for chatgpt \u2014 use low/medium/high/xhigh/max');
   }
 }
-function translateAnthropicThinking(spec) {
+function translateAnthropicThinking(spec, model) {
   if (spec === "auto") return { patch: {}, degraded: false };
   switch (spec.kind) {
     case "off":
@@ -1617,23 +1879,31 @@ function translateAnthropicThinking(spec) {
         patch: { thinking: { type: "enabled", budget_tokens: spec.budgetTokens } },
         degraded: false
       };
-    case "effort":
-      return degrade('thinking "effort" is not supported for anthropic \u2014 use budget:N');
+    case "effort": {
+      const levels = effortLevelsFor("anthropic", model);
+      if (levels.length === 0) {
+        return degrade('thinking "effort" is not supported for this Claude model \u2014 use budget:N');
+      }
+      const resolved = clampEffort("anthropic", model, spec.effort);
+      return withClampNote(
+        { output_config: { effort: resolved.effort } },
+        resolved.clamped,
+        resolved.note
+      );
+    }
   }
 }
-var PROVIDER_THINKING_CAPABILITY;
+var EFFORT_RANK;
 var init_thinking = __esm({
   "src/cli/thinking.ts"() {
     "use strict";
-    PROVIDER_THINKING_CAPABILITY = {
-      "openai-compatible": { effort: true },
-      "grok": { effort: true },
-      "chatgpt": { effort: true },
-      "anthropic": { budget: true },
-      "glm": { budget: true },
-      "deepseek": { effort: true },
-      "minimax": { effort: true },
-      "custom": { effort: true }
+    init_thinkingCapability();
+    EFFORT_RANK = {
+      low: 1,
+      medium: 2,
+      high: 3,
+      xhigh: 4,
+      max: 5
     };
   }
 });
@@ -1826,14 +2096,14 @@ var init_providerConfig = __esm({
     DEFAULTS = {
       activeProviderId: "openai-compatible",
       modelByProvider: {
-        // grok-4.5: flagship; reasoning_effort defaults to "high" on the xAI API
-        "openai-compatible": "grok-4.5",
+        // grok-4.6: flagship; native reasoning_effort includes xhigh
+        "openai-compatible": "grok-4.6",
         "minimax": "MiniMax-M2.5",
         "glm": "glm-4.6",
-        "grok": "grok-4.5",
+        "grok": "grok-4.6",
         "deepseek": "deepseek-v4-pro",
-        "chatgpt": "gpt-5.2-codex",
-        "anthropic": "claude-sonnet-4-5",
+        "chatgpt": "gpt-5.6-codex",
+        "anthropic": "claude-sonnet-4-6",
         "custom": ""
       },
       thinkingByProvider: {
@@ -1860,6 +2130,7 @@ __export(modelDiscovery_exports, {
   getCachedModels: () => getCachedModels,
   getDiscoveredModelIds: () => getDiscoveredModelIds,
   getModelsFilePath: () => getModelsFilePath,
+  getStaticFallbackModels: () => getStaticFallbackModels,
   isModelsCacheStale: () => isModelsCacheStale,
   loadModelsRegistry: () => loadModelsRegistry,
   pickDefaultModel: () => pickDefaultModel
@@ -1867,6 +2138,9 @@ __export(modelDiscovery_exports, {
 import { promises as fs3, existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
 import { homedir } from "node:os";
 import path5 from "node:path";
+function getStaticFallbackModels(provider) {
+  return STATIC_FALLBACKS[provider] ? [...STATIC_FALLBACKS[provider]] : [];
+}
 async function resolveDiscoveryBaseUrl(provider, options) {
   if (options.baseUrl) return options.baseUrl;
   const { getCustomEndpoint: getCustomEndpoint2 } = await Promise.resolve().then(() => (init_providerConfig(), providerConfig_exports));
@@ -2002,10 +2276,6 @@ async function discoverModelsForProvider(provider, options = {}) {
     const headers2 = await resolveDiscoveryHeaders(provider, authToken);
     response = await fetchImpl(url2, { method: "GET", headers: headers2 });
   } catch (err) {
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, `network: ${err instanceof Error ? err.message : String(err)}`);
-    }
     throw new ModelDiscoveryError(
       `Network error contacting ${url2}: ${err instanceof Error ? err.message : String(err)}`,
       "network_error"
@@ -2013,10 +2283,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   }
   if (!response.ok) {
     const body = await response.text().catch(() => "");
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, `HTTP ${response.status}: ${body.slice(0, 80)}`);
-    }
     throw new ModelDiscoveryError(
       `HTTP ${response.status} from ${url2}: ${body.slice(0, 200)}`,
       `http_${response.status}`
@@ -2026,10 +2292,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   try {
     json2 = await response.json();
   } catch (err) {
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, "invalid_json");
-    }
     throw new ModelDiscoveryError(
       `Invalid JSON from ${url2}: ${err instanceof Error ? err.message : String(err)}`,
       "invalid_json"
@@ -2037,10 +2299,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   }
   const models = provider === "anthropic" ? parseAnthropicModelsResponse(json2) : parseOpenAIModelsResponse(json2, baseUrl);
   if (models.length === 0) {
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, "empty_response");
-    }
     throw new ModelDiscoveryError(
       `Provider ${provider} returned 0 models \u2014 refusing to overwrite cache`,
       "empty_response"
@@ -2060,22 +2318,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   }
   return entry;
 }
-async function cacheFallback(provider, baseUrl, models, options, lastError) {
-  const entry = {
-    models,
-    fetchedAt: Date.now(),
-    baseUrl,
-    lastError
-  };
-  if (!options.skipCacheWrite) {
-    const file2 = getModelsFilePath();
-    await readModifyWriteRegistry((current) => {
-      current[provider] = entry;
-      return current;
-    }, file2);
-  }
-  return entry;
-}
 function discoverModelsInBackground(provider, options = {}) {
   discoverModelsForProvider(provider, options).catch((err) => {
     if (err instanceof ModelDiscoveryError && options.onError) {
@@ -2113,6 +2355,9 @@ var init_modelDiscovery = __esm({
     };
     STATIC_FALLBACKS = {
       chatgpt: [
+        { id: "gpt-5.6-codex", displayName: "GPT-5.6 Codex" },
+        { id: "gpt-5.6", displayName: "GPT-5.6" },
+        { id: "gpt-5.4", displayName: "GPT-5.4" },
         { id: "gpt-5.2-codex", displayName: "GPT-5.2 Codex" },
         { id: "gpt-5.2", displayName: "GPT-5.2" },
         { id: "gpt-5.1-codex", displayName: "GPT-5.1 Codex" },
@@ -2121,9 +2366,19 @@ var init_modelDiscovery = __esm({
         { id: "o4-mini", displayName: "o4-mini" }
       ],
       anthropic: [
+        { id: "claude-opus-4-7", displayName: "Claude Opus 4.7" },
         { id: "claude-opus-4-6", displayName: "Claude Opus 4.6" },
+        { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6" },
         { id: "claude-sonnet-4-5", displayName: "Claude Sonnet 4.5" },
         { id: "claude-haiku-4-5", displayName: "Claude Haiku 4.5" }
+      ],
+      grok: [
+        { id: "grok-4.6", displayName: "Grok 4.6" },
+        { id: "grok-4.5", displayName: "Grok 4.5" }
+      ],
+      glm: [
+        { id: "glm-5.3", displayName: "GLM-5.3" },
+        { id: "glm-4.6", displayName: "GLM-4.6" }
       ]
     };
     writeChain = Promise.resolve();
@@ -28169,7 +28424,7 @@ function openaiCompatibleProvider(config2) {
       if (thinking.thinking) body.thinking = { type: thinking.thinking };
       if (thinking.reasoningEffort) body.reasoning_effort = thinking.reasoningEffort;
     } else if (thinkingSpec !== "auto") {
-      const t = translateOpenAiCompatibleThinking(config2.providerId, thinkingSpec);
+      const t = translateOpenAiCompatibleThinking(config2.providerId, thinkingSpec, config2.model);
       if (t.degraded) {
         console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       } else {
@@ -28703,7 +28958,7 @@ function anthropicMessagesProvider(config2) {
     }
     const thinkingSpec = config2.thinking ?? "auto";
     if (thinkingSpec !== "auto") {
-      const t = translateAnthropicThinking(thinkingSpec);
+      const t = translateAnthropicThinking(thinkingSpec, config2.model);
       if (t.degraded) console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       else Object.assign(body, t.patch);
     }
@@ -28915,7 +29170,7 @@ function chatgptResponsesProvider(config2) {
     }
     const thinkingSpec = config2.thinking ?? "auto";
     if (thinkingSpec !== "auto") {
-      const t = translateResponsesThinking(thinkingSpec);
+      const t = translateResponsesThinking(thinkingSpec, config2.model);
       if (t.degraded) console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       else Object.assign(body, t.patch);
     }
@@ -42695,9 +42950,9 @@ var init_oauthDesktop = __esm({
     init_chatgptOAuth();
     init_anthropicOAuth();
     DEFAULT_MODELS = {
-      grok: "grok-4.5",
-      chatgpt: "gpt-5.2-codex",
-      anthropic: "claude-sonnet-4-5"
+      grok: "grok-4.6",
+      chatgpt: "gpt-5.6-codex",
+      anthropic: "claude-sonnet-4-6"
     };
   }
 });
@@ -42957,12 +43212,12 @@ function handleModelSet(ctx, model) {
 }
 function handleEffortShow(ctx) {
   const id = ctx.activeProviderSpec.id;
-  const cap3 = thinkingCapabilityFor(id);
+  const cap3 = thinkingCapabilityFor(id, ctx.activeModel);
   const current = stringifyThinkingSpec(getThinkingForProvider(id));
   const options = [
     "auto",
     "off",
-    ...cap3.effort ? ["low", "medium", "high"] : [],
+    ...cap3.efforts ?? (cap3.effort ? ["low", "medium", "high"] : []),
     ...cap3.budget ? ["budget:<tokens>"] : []
   ];
   appendSystem(
@@ -42975,7 +43230,7 @@ function handleEffortSet(ctx, raw) {
   if (!isValidThinkingInput(raw)) {
     appendSystem(
       ctx.setMessages,
-      `[effort] invalid spec "${raw}" \u2014 use auto | off | low | medium | high | budget:<tokens>`
+      `[effort] invalid spec "${raw}" \u2014 use auto | off | low | medium | high | xhigh | max | budget:<tokens>`
     );
     return;
   }
@@ -43536,6 +43791,11 @@ function buildDesktopConfigSnapshot() {
   const providers = PROVIDERS.map((p3) => {
     const cached2 = getCachedModels(p3.id);
     const models = cached2?.models.map((m) => m.id) ?? [];
+    if (models.length === 0) {
+      for (const m of getStaticFallbackModels(p3.id)) {
+        if (!models.includes(m.id)) models.push(m.id);
+      }
+    }
     const defaultModel = config2.modelByProvider[p3.id] ?? "";
     if (defaultModel && !models.includes(defaultModel)) {
       models.unshift(defaultModel);
@@ -43559,7 +43819,7 @@ function buildDesktopConfigSnapshot() {
       hasRefreshToken: Boolean(stored?.refreshToken),
       oauthSupported: isOAuthProvider(p3.id),
       thinking: config2.thinkingByProvider[p3.id] ?? "auto",
-      thinkingCapability: thinkingCapabilityFor(p3.id)
+      thinkingCapability: thinkingCapabilityFor(p3.id, defaultModel)
     };
   });
   return {