@triflux/remote 10.86.1 → 10.88.0

package/scripts/lib/model-effort.mjs

@@ -0,0 +1,134 @@
+import {
+  AGY_FAMILY_PROFILES,
+  CODEX_FAMILY_PROFILES,
+  readCodexModelCatalog,
+  resolveModelFamilies,
+} from "./model-family-resolver.mjs";
+
+export const EFFORT_ORDER = Object.freeze([
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra",
+]);
+
+const LEGACY_CANONICAL_PROFILE_ALIASES = Object.freeze({
+  gpt56_sol_xhigh: "astra_xhigh",
+  gpt56_sol_max: "astra_max",
+  gpt56_sol_ultra: "astra_ultra",
+  gpt56_terra_high: "sol_high",
+  gpt56_terra_med: "sol_med",
+});
+
+export function normalizeCodexProfileName(profileName) {
+  const normalized = String(profileName ?? "").trim();
+  if (Object.hasOwn(LEGACY_CANONICAL_PROFILE_ALIASES, normalized))
+    return LEGACY_CANONICAL_PROFILE_ALIASES[normalized];
+  const familyName = normalized.replace(/^gpt\d+_(sol|astra|luna)_/, "$1_");
+  return Object.hasOwn(CODEX_FAMILY_PROFILES, familyName)
+    ? familyName
+    : normalized;
+}
+
+export function normalizeGeminiProfileName(name) {
+  const raw = String(name ?? "").trim();
+  // 옛 Flash 이름은 effort와 상관없이 Argon Low로 보낸다.
+  return raw.replace(/^flash\d*(?:_(?:low|high))?$/, "argon_low");
+}
+
+export function modelEffortFromProfile(cli, profile, effort) {
+  if (effort !== undefined) {
+    const definitions =
+      cli === "codex"
+        ? CODEX_FAMILY_PROFILES
+        : cli === "antigravity" || cli === "agy"
+          ? AGY_FAMILY_PROFILES
+          : {};
+    return EFFORT_ORDER.includes(effort) &&
+      Object.values(definitions).some(({ family }) => family === profile)
+      ? { family: profile, effort }
+      : null;
+  }
+  let definition;
+  if (cli === "codex") {
+    const normalized = normalizeCodexProfileName(profile);
+    const name =
+      normalized === "max" || normalized === "ultra"
+        ? `astra_${normalized}`
+        : normalized;
+    if (Object.hasOwn(CODEX_FAMILY_PROFILES, name))
+      definition = CODEX_FAMILY_PROFILES[name];
+  } else if (cli === "antigravity" || cli === "agy") {
+    const name = normalizeGeminiProfileName(profile);
+    if (Object.hasOwn(AGY_FAMILY_PROFILES, name))
+      definition = AGY_FAMILY_PROFILES[name];
+  }
+  return definition
+    ? { family: definition.family, effort: definition.effort }
+    : null;
+}
+
+export function profileFromModelEffort(cli, { family, effort }) {
+  const profiles =
+    cli === "codex"
+      ? CODEX_FAMILY_PROFILES
+      : cli === "antigravity" || cli === "agy"
+        ? AGY_FAMILY_PROFILES
+        : {};
+  return (
+    Object.entries(profiles).find(
+      ([, value]) => value.family === family && value.effort === effort,
+    )?.[0] || null
+  );
+}
+
+export function resolveCodexModelEffort({ family, effort }, opts = {}) {
+  const { families } = resolveModelFamilies("codex", {
+    ...opts,
+    allowCommand: false,
+    persist: false,
+  });
+  if (!Object.hasOwn(families, family) || !EFFORT_ORDER.includes(effort)) {
+    throw new Error(`알 수 없는 Codex 가족 또는 effort: ${family}/${effort}`);
+  }
+  const model = families[family].model;
+  const supported = readCodexModelCatalog(opts)?.models?.find(
+    (entry) => entry?.slug === model,
+  )?.supported_reasoning_levels;
+  if (!Array.isArray(supported)) return { family, model, effort };
+  const levels = supported.map((level) => level?.effort ?? level);
+  const selected = EFFORT_ORDER.slice(0, EFFORT_ORDER.indexOf(effort) + 1)
+    .filter((level) => levels.includes(level))
+    .at(-1);
+  if (!selected) {
+    const error = new Error(
+      `${model}: ${effort} 이하의 지원 effort가 없습니다`,
+    );
+    error.code = "unsupported-effort";
+    throw error;
+  }
+  return { family, model, effort: selected };
+}
+
+export function resolveAgyModelEffort({ family, effort }, opts = {}) {
+  const { families } = resolveModelFamilies("agy", opts);
+  if (!Object.hasOwn(families, family) || !EFFORT_ORDER.includes(effort)) {
+    throw new Error(`알 수 없는 agy 가족 또는 effort: ${family}/${effort}`);
+  }
+  const { model, supportedEfforts } = families[family];
+  if (!supportedEfforts) return { family, model, effort };
+  const selected = EFFORT_ORDER.slice(0, EFFORT_ORDER.indexOf(effort) + 1)
+    .filter((level) => supportedEfforts.includes(level))
+    .at(-1);
+  if (!selected) {
+    const error = new Error(
+      `${model}: ${effort} 이하의 지원 effort가 없습니다`,
+    );
+    error.code = "unsupported-effort";
+    throw error;
+  }
+  return { family, model, effort: selected };
+}

package/scripts/lib/model-family-resolver.mjs

@@ -39,7 +39,8 @@ export const AGY_FAMILY_PROFILES = Object.freeze({
 });
 const DAY_MS = 86_400_000;
 const CODEX_SLUG = /^gpt-(\d+(?:\.\d+)*)-(sol|astra|terra|luna)$/;
-const AGY_SLUG = /^gemini-(\d+(?:\.\d+)*)-(argon)-(low|medium|high)$/;
+const AGY_SLUG =
+  /^gemini-(\d+(?:\.\d+)*)-(argon)-(none|low|medium|high|xhigh|max|ultra)$/;
 
 function compareVersions(a, b) {
   const left = a.split(".").map(Number);
@@ -59,10 +60,11 @@ export function selectCodexModel(models, family, effort) {
         return (
           match?.[2] === family &&
           item.visibility === "list" &&
-          Array.isArray(item.supported_reasoning_levels) &&
-          item.supported_reasoning_levels.some(
-            (level) => (level?.effort ?? level) === effort,
-          )
+          (effort === undefined ||
+            (Array.isArray(item.supported_reasoning_levels) &&
+              item.supported_reasoning_levels.some(
+                (level) => (level?.effort ?? level) === effort,
+              )))
         );
       })
       .sort((a, b) =>
@@ -89,7 +91,7 @@ export function selectAgyModel(models, family, effort) {
         const match = AGY_SLUG.exec(item?.slug);
         return (
           match?.[2] === family &&
-          match?.[3] === effort &&
+          (effort === undefined || match?.[3] === effort) &&
           typeof item.model === "string"
         );
       })
@@ -203,7 +205,7 @@ export function resolveModelFamilies(provider, opts = {}) {
   if (provider === "codex") {
     const cachePath = join(paths.codexHome, "models_cache.json");
     sourceSignature = signature(cachePath);
-    if (sourceSignature !== previous.sourceSignature)
+    if (sourceSignature !== previous.sourceSignature || !previous.families)
       catalog = readCodexModelCatalog(opts);
     if (
       sourceSignature.endsWith(":missing") &&
@@ -266,6 +268,8 @@ export function resolveModelFamilies(provider, opts = {}) {
   }
   const profiles = {};
   const selectedProfiles = {};
+  const families = {};
+  const selectedFamilies = {};
   const pins = readJson(paths.pinsPath) || {};
   for (const [name, definition] of Object.entries(definitions)) {
     const saved = previous.profiles?.[name];
@@ -329,13 +333,74 @@ export function resolveModelFamilies(provider, opts = {}) {
         fetched_at: null,
       };
     }
+    if (provider === "codex" && !Object.hasOwn(families, definition.family)) {
+      const latest = selectCodexModel(catalog?.models, definition.family);
+      const lastFamily =
+        previous.families?.[definition.family] || profiles[name];
+      families[definition.family] =
+        latest &&
+        (!lastFamily.fetched_at ||
+          !catalog.fetched_at ||
+          Date.parse(catalog.fetched_at) >= Date.parse(lastFamily.fetched_at))
+          ? { model: latest.slug, fetched_at: catalog.fetched_at || fetchedAt }
+          : { model: lastFamily.model, fetched_at: lastFamily.fetched_at };
+      selectedFamilies[definition.family] =
+        typeof pin === "string" &&
+        CODEX_SLUG.exec(pin)?.[2] === definition.family
+          ? { model: pin, source: paths.pinsPath, fetched_at: null }
+          : { ...families[definition.family] };
+    }
+  }
+  if (provider === "agy") {
+    const latest = selectAgyModel(catalog?.models, "argon");
+    // 옛 기록에는 가족 ID가 없으므로 마지막 성공 프로필의 표시 이름에서 복원한다.
+    const savedModels = [
+      ...Object.values(AGY_FAMILY_PROFILES),
+      ...Object.values(profiles),
+    ].flatMap((profile) => {
+      const match = /^Gemini (\d+(?:\.\d+)*) Argon \(/i.exec(profile.model);
+      return match
+        ? [{ ...profile, slug: `gemini-${match[1]}-argon-${profile.effort}` }]
+        : [];
+    });
+    const saved = selectAgyModel(savedModels, "argon");
+    const last = previous.families?.argon || {
+      model: saved.slug.replace(/-[^-]+$/, ""),
+      fetched_at: saved.fetched_at,
+    };
+    families.argon =
+      latest &&
+      (!last.fetched_at ||
+        !catalog.fetched_at ||
+        Date.parse(catalog.fetched_at) >= Date.parse(last.fetched_at))
+        ? {
+            model: latest.slug.replace(/-[^-]+$/, ""),
+            fetched_at: catalog.fetched_at || fetchedAt,
+          }
+        : last;
+    const pin = pins.argon;
+    selectedFamilies.argon =
+      typeof pin === "string" && AGY_SLUG.test(`${pin}-low`)
+        ? { model: pin, source: paths.pinsPath, fetched_at: null }
+        : { ...families.argon };
+    const supported = catalog?.models
+      ?.filter((item) =>
+        item.slug.startsWith(`${selectedFamilies.argon.model}-`),
+      )
+      .map((item) => AGY_SLUG.exec(item.slug)?.[3])
+      .filter(Boolean);
+    if (supported?.length) selectedFamilies.argon.supportedEfforts = supported;
   }
   const record = {
     sourceSignature,
     checked_at: checkedAt || null,
     profiles,
     selectedProfiles,
+    families,
   };
   if (opts.persist !== false) saveJson(recordPath, record);
-  return { profiles: selectedProfiles };
+  return {
+    profiles: selectedProfiles,
+    families: selectedFamilies,
+  };
 }