@bman654/clodex 2.18.5 → 2.18.6

package/dist/cli.js

@@ -74,7 +74,7 @@ import {
   withRegistryWriteLockSync,
   writeParentNoticeLines,
   writeParentNoticeLinesSync
-} from "./chunk-YGEPQOPA.js";
+} from "./chunk-VFYRDLDD.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -346,7 +346,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.18.5",
+  version: "2.18.6",
   publishConfig: {
     access: "public"
   },
@@ -6062,16 +6062,33 @@ function compareCodexClientVersions(a, b) {
   }
   return 0;
 }
-function requiresNewerCodexClient(model) {
-  if (!model.useResponsesLite) return false;
+function atLeast(version, floor) {
+  const order = compareCodexClientVersions(version, floor);
+  return order === 0 || order === 1;
+}
+function codexClientRequirement(model) {
+  if (!model.useResponsesLite) return void 0;
   const minimum = readCodexClientVersion(model.minimalClientVersion);
-  return minimum !== void 0 && compareCodexClientVersions(minimum, CODEX_RESPONSES_LITE_VERSION) === 1;
+  const withheldAt = readCodexClientVersion(model.withheldAtClientVersion);
+  const blockingMinimum = minimum !== void 0 && compareCodexClientVersions(minimum, CODEX_RESPONSES_LITE_VERSION) === 1 ? minimum : void 0;
+  const blockingWithheld = withheldAt !== void 0 && atLeast(withheldAt, CODEX_RESPONSES_LITE_VERSION) ? withheldAt : void 0;
+  if (blockingMinimum !== void 0 && (blockingWithheld === void 0 || compareCodexClientVersions(blockingMinimum, blockingWithheld) === 1)) {
+    return { kind: "minimum", version: blockingMinimum };
+  }
+  return blockingWithheld === void 0 ? void 0 : { kind: "withheld", version: blockingWithheld };
+}
+function requiresNewerCodexClient(model) {
+  return codexClientRequirement(model) !== void 0;
 }
 function codexClientVersionWarning(models) {
-  const unavailable = models.filter(requiresNewerCodexClient);
+  const unavailable = models.flatMap((model) => {
+    const requirement = codexClientRequirement(model);
+    return requirement ? [{ id: model.id, requirement }] : [];
+  });
   if (unavailable.length === 0) return void 0;
-  const details = unavailable.map((model) => `${printableServerText(model.id)} (requires ${model.minimalClientVersion})`).join(", ");
-  return `Hidden ChatGPT-plan models: ${details}. clodex sends Codex client version ${CODEX_RESPONSES_LITE_VERSION} for Responses-Lite; their catalog minimum exceeds this version. Update clodex to a release supporting their required version to use them.`;
+  const details = unavailable.map(({ id, requirement }) => `${printableServerText(id)} (requires ${requirement.kind === "minimum" ? requirement.version : `a version newer than ${requirement.version}`})`).join(", ");
+  const reason = unavailable.every(({ requirement }) => requirement.kind === "minimum") ? "their catalog minimum exceeds this version" : "the ChatGPT catalog does not offer them to this version";
+  return `Hidden ChatGPT-plan models: ${details}. clodex sends Codex client version ${CODEX_RESPONSES_LITE_VERSION} for Responses-Lite; ${reason}. Update clodex to a release supporting their required version to use them.`;
 }
 
 // src/data/openai-oauth-models.ts
@@ -16629,12 +16646,7 @@ async function resolveRefreshCredentialWithSource(provider, resolveKey, selected
   return resolved;
 }
 
-// src/registry/refresh-models.ts
-async function refreshOAuthProvider(provider, accessToken) {
-  const tpl = provider.templateId ?? provider.id;
-  if (tpl === "openai" || tpl === "openai-oauth") return refreshOpenAiOAuthModels(accessToken);
-  throw new Error(`refreshOAuthProvider: unsupported template "${tpl}"`);
-}
+// src/registry/openai-oauth-catalog.ts
 function positiveInteger2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
 }
@@ -16754,7 +16766,41 @@ async function fetchJsonWithAuth(url, accessToken, timeoutMs) {
     }
   }
 }
-async function refreshOpenAiOAuthModels(accessToken) {
+async function markModelsWithheldAtRequestVersion(models, accessToken, timeoutMs, previous) {
+  const pinned = await fetchJsonWithAuth(
+    `https://chatgpt.com/backend-api/codex/models?client_version=${CODEX_RESPONSES_LITE_VERSION}`,
+    accessToken,
+    timeoutMs
+  );
+  const offered = readOfferedIds(pinned.body);
+  if (!offered) return carryWithheldMarkers(models, previous);
+  return models.map((model) => offered.has(model.id) ? model : { ...model, withheldAtClientVersion: CODEX_RESPONSES_LITE_VERSION });
+}
+function readOfferedIds(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const record = body;
+  const shape = Array.isArray(record.models) ? { rows: record.models, key: "slug" } : Array.isArray(record.data) ? { rows: record.data, key: "id" } : void 0;
+  if (!shape || shape.rows.length === 0) return void 0;
+  const ids = /* @__PURE__ */ new Set();
+  for (const row of shape.rows) {
+    const id = row !== null && typeof row === "object" ? row[shape.key] : void 0;
+    if (typeof id !== "string" || id === "" || id !== id.trim()) return void 0;
+    ids.add(id);
+  }
+  return ids;
+}
+function carryWithheldMarkers(models, previous) {
+  const withheld = new Map(previous.flatMap((model) => {
+    const version = readCodexClientVersion(model.withheldAtClientVersion);
+    return version ? [[model.id, version]] : [];
+  }));
+  if (withheld.size === 0) return models;
+  return models.map((model) => {
+    const version = withheld.get(model.id);
+    return version ? { ...model, withheldAtClientVersion: version } : model;
+  });
+}
+async function refreshOpenAiOAuthModels(accessToken, previous = []) {
   const TIMEOUT_MS = 1e4;
   const seedById = new Map(buildOpenAiOAuthModels().map((m) => [m.id, m]));
   const toModels = (entries, codexCatalog) => entries.map((entry) => buildDynamicOAuthModel(entry, seedById, codexCatalog));
@@ -16766,7 +16812,11 @@ async function refreshOpenAiOAuthModels(accessToken) {
   );
   const codexEntries = parseOpenAiModelEntries(codexResult.body);
   if (codexEntries.length > 0) {
-    return { models: toModels(codexEntries, true), source: "live" };
+    const models = toModels(codexEntries, true);
+    return {
+      models: await markModelsWithheldAtRequestVersion(models, accessToken, TIMEOUT_MS, previous),
+      source: "live"
+    };
   }
   const chatGptResult = await fetchJsonWithAuth(
     "https://chatgpt.com/backend-api/models",
@@ -16775,7 +16825,10 @@ async function refreshOpenAiOAuthModels(accessToken) {
   );
   const chatGptEntries = parseOpenAiModelEntries(chatGptResult.body).filter(({ id }) => !CHATGPT_CODEX_UNSUPPORTED_MODELS.has(id));
   if (chatGptEntries.length > 0) {
-    return { models: toModels(chatGptEntries, false), source: "live" };
+    return {
+      models: carryWithheldMarkers(toModels(chatGptEntries, false), previous),
+      source: "live"
+    };
   }
   const failures = [codexResult.error, chatGptResult.error].filter((error) => error !== void 0);
   const credentialFailure = failures.find((error) => /(?:\brejected\b|\b401\b|\b403\b)/i.test(error));
@@ -16786,6 +16839,15 @@ async function refreshOpenAiOAuthModels(accessToken) {
     credentialRejected: credentialFailure !== void 0
   };
 }
+
+// src/registry/refresh-models.ts
+async function refreshOAuthProvider(provider, accessToken) {
+  const tpl = provider.templateId ?? provider.id;
+  if (tpl === "openai" || tpl === "openai-oauth") {
+    return refreshOpenAiOAuthModels(accessToken, provider.modelsCache?.models);
+  }
+  throw new Error(`refreshOAuthProvider: unsupported template "${tpl}"`);
+}
 function warningSuffix(models) {
   const warning = codexClientVersionWarning(applyOAuthSeedContextMetadata(models));
   return warning ? ` ${warning}` : "";