@iam-brain/opencode-codex-auth 1.2.4 → 1.3.0

package/dist/lib/model-catalog.js

@@ -1,768 +1,4 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { resolveCustomPersonalityDescription } from "./personalities.js";
-import { fetchRemoteText } from "./remote-cache-fetch.js";
-import { isFsErrorCode, readJsonFileBestEffort, writeJsonFileBestEffort } from "./cache-io.js";
-import { withLockedDirectory } from "./cache-lock.js";
-import { buildCodexModelsMemoryCacheKey, codexAuthModelsCachePath, codexModelsCompatShardPath, codexModelsMetaPath, codexModelsSharedCachePath, isCodexModelsCacheFileName, resolveCodexCacheDir } from "./codex-cache-layout.js";
-const CODEX_MODELS_ENDPOINT = "https://chatgpt.com/backend-api/codex/models";
-const CODEX_GITHUB_MODELS_URL_PREFIX = "https://raw.githubusercontent.com/openai/codex";
-const DEFAULT_CLIENT_VERSION = "0.97.0";
-const CACHE_TTL_MS = 15 * 60 * 1000;
-const FETCH_TIMEOUT_MS = 5000;
-const EFFORT_SUFFIX_REGEX = /-(none|minimal|low|medium|high|xhigh)$/i;
-const UNRESOLVED_TEMPLATE_MARKER_REGEX = /\{\{\s*[^}]+\s*\}\}/;
-const STALE_BRIDGE_MARKERS = [
-    /multi_tool_use\.parallel/i,
-    /assistant\s+to=multi_tool_use\.parallel/i,
-    /functions\.(read|exec_command|write_stdin|apply_patch|edit|grep|glob|list)\b/i,
-    /recipient_name\s*[:=]/i
-];
-const REASONING_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh"]);
-const TEXT_VERBOSITY = new Set(["low", "medium", "high"]);
-const inMemoryCatalog = new Map();
-const inFlightCatalogFetches = new Map();
-function cacheKey(cacheDir, accountId) {
-    return buildCodexModelsMemoryCacheKey(cacheDir, accountId);
-}
-function cachePath(cacheDir, accountId) {
-    return codexAuthModelsCachePath(cacheDir, accountId);
-}
-function opencodeShardCachePath(cacheDir, accountId) {
-    return codexModelsCompatShardPath(cacheDir, accountId);
-}
-function opencodeSharedCachePath(cacheDir) {
-    return codexModelsSharedCachePath(cacheDir);
-}
-function parseSemver(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    const match = trimmed.match(/^(\d+)\.(\d+)\.(\d+)$/);
-    if (!match)
-        return undefined;
-    return [Number.parseInt(match[1], 10), Number.parseInt(match[2], 10), Number.parseInt(match[3], 10)];
-}
-function compareSemver(a, b) {
-    if (a[0] !== b[0])
-        return a[0] - b[0];
-    if (a[1] !== b[1])
-        return a[1] - b[1];
-    return a[2] - b[2];
-}
-function normalizeSemver(value) {
-    const parsed = parseSemver(value);
-    if (!parsed)
-        return undefined;
-    return `${parsed[0]}.${parsed[1]}.${parsed[2]}`;
-}
-function githubModelsTag(version) {
-    return `rust-v${version}`;
-}
-function githubModelsUrl(version) {
-    return `${CODEX_GITHUB_MODELS_URL_PREFIX}/${githubModelsTag(version)}/codex-rs/core/models.json`;
-}
-function semverFromTag(tag) {
-    if (!tag)
-        return undefined;
-    const match = tag.match(/(\d+\.\d+\.\d+)/);
-    if (!match?.[1])
-        return undefined;
-    return normalizeSemver(match[1]);
-}
-async function readGitHubModelsCacheMeta(cacheDir) {
-    const file = codexModelsMetaPath(cacheDir);
-    const parsed = await readJsonFileBestEffort(file);
-    if (!isRecord(parsed))
-        return undefined;
-    const parsedVersion = normalizeSemver(typeof parsed.version === "string" ? parsed.version : undefined);
-    const parsedTag = typeof parsed.tag === "string" ? parsed.tag.trim() : "";
-    const tag = parsedTag || (parsedVersion ? githubModelsTag(parsedVersion) : "");
-    const url = typeof parsed.url === "string" ? parsed.url.trim() : "";
-    const lastChecked = typeof parsed.lastChecked === "number" && Number.isFinite(parsed.lastChecked) ? parsed.lastChecked : 0;
-    const etag = typeof parsed.etag === "string" ? parsed.etag.trim() : undefined;
-    if (!tag || !url)
-        return undefined;
-    return { etag, tag, url, lastChecked };
-}
-async function writeGitHubModelsCacheMeta(cacheDir, meta) {
-    const file = codexModelsMetaPath(cacheDir);
-    await writeJsonFileBestEffort(file, meta);
-}
-async function refreshSharedGitHubModelsCache(input) {
-    const targetVersion = normalizeSemver(input.targetClientVersion);
-    if (!targetVersion)
-        return;
-    const existingMeta = await readGitHubModelsCacheMeta(input.cacheDir);
-    const existingVersion = parseSemver(semverFromTag(existingMeta?.tag));
-    const target = parseSemver(targetVersion);
-    if (!target)
-        return;
-    if (existingVersion && compareSemver(existingVersion, target) >= 0)
-        return;
-    const tag = githubModelsTag(targetVersion);
-    const url = githubModelsUrl(targetVersion);
-    const result = await fetchRemoteText({
-        key: "models",
-        url,
-        etag: existingMeta?.url === url ? existingMeta.etag : undefined
-    }, {
-        fetchImpl: input.fetchImpl,
-        timeoutMs: FETCH_TIMEOUT_MS,
-        allowedHosts: ["raw.githubusercontent.com"]
-    });
-    if (result.status === "not_modified" && existingMeta) {
-        await writeGitHubModelsCacheMeta(input.cacheDir, {
-            etag: existingMeta.etag,
-            tag,
-            lastChecked: input.now,
-            url
-        });
-        return;
-    }
-    if (result.status !== "ok") {
-        return;
-    }
-    try {
-        const payload = JSON.parse(result.text);
-        const models = parseCatalogResponse(payload);
-        if (models.length === 0)
-            return;
-        const etag = result.etag || (existingMeta?.url === url ? existingMeta.etag : undefined);
-        const file = opencodeSharedCachePath(input.cacheDir);
-        await writeJsonFileBestEffort(file, { fetchedAt: input.now, source: "github", models });
-        await writeGitHubModelsCacheMeta(input.cacheDir, {
-            etag,
-            tag,
-            lastChecked: input.now,
-            url
-        });
-    }
-    catch (error) {
-        // Best effort refresh; continue without blocking catalog load.
-    }
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeModelSlug(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const normalized = value.trim().toLowerCase();
-    return normalized ? normalized : undefined;
-}
-function compareModelSlugs(a, b) {
-    return a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" });
-}
-function normalizeReasoningEffort(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const normalized = value.trim().toLowerCase();
-    if (REASONING_EFFORTS.has(normalized)) {
-        return normalized;
-    }
-    return undefined;
-}
-function normalizeVerbosity(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const normalized = value.trim().toLowerCase();
-    if (TEXT_VERBOSITY.has(normalized)) {
-        return normalized;
-    }
-    return undefined;
-}
-function parseReasoningLevels(value) {
-    if (!Array.isArray(value))
-        return null;
-    const out = [];
-    for (const item of value) {
-        if (!isRecord(item))
-            continue;
-        const effort = normalizeReasoningEffort(item.effort);
-        if (!effort)
-            continue;
-        out.push({ effort });
-    }
-    return out.length > 0 ? out : null;
-}
-function parseCatalogResponse(payload) {
-    if (!isRecord(payload))
-        return [];
-    const root = payload;
-    if (!Array.isArray(root.models))
-        return [];
-    const deduped = new Map();
-    for (const item of root.models) {
-        if (!isRecord(item))
-            continue;
-        const slug = normalizeModelSlug(item.slug);
-        if (!slug)
-            continue;
-        deduped.set(slug, {
-            slug,
-            model_messages: isRecord(item.model_messages)
-                ? {
-                    instructions_template: typeof item.model_messages.instructions_template === "string"
-                        ? item.model_messages.instructions_template
-                        : null,
-                    instructions_variables: isRecord(item.model_messages.instructions_variables)
-                        ? {
-                            personality: typeof item.model_messages.instructions_variables.personality === "string"
-                                ? item.model_messages.instructions_variables.personality
-                                : null,
-                            personality_default: typeof item.model_messages.instructions_variables.personality_default === "string"
-                                ? item.model_messages.instructions_variables.personality_default
-                                : null,
-                            personality_friendly: typeof item.model_messages.instructions_variables.personality_friendly === "string"
-                                ? item.model_messages.instructions_variables.personality_friendly
-                                : null,
-                            personality_pragmatic: typeof item.model_messages.instructions_variables.personality_pragmatic === "string"
-                                ? item.model_messages.instructions_variables.personality_pragmatic
-                                : null,
-                            personalities: isRecord(item.model_messages.instructions_variables.personalities)
-                                ? item.model_messages.instructions_variables.personalities
-                                : null
-                        }
-                        : null
-                }
-                : null,
-            base_instructions: typeof item.base_instructions === "string" ? item.base_instructions : null,
-            apply_patch_tool_type: typeof item.apply_patch_tool_type === "string" ? item.apply_patch_tool_type : null,
-            supported_reasoning_levels: parseReasoningLevels(item.supported_reasoning_levels),
-            default_reasoning_level: typeof item.default_reasoning_level === "string" ? item.default_reasoning_level : null,
-            supports_reasoning_summaries: typeof item.supports_reasoning_summaries === "boolean" ? item.supports_reasoning_summaries : null,
-            reasoning_summary_format: typeof item.reasoning_summary_format === "string" ? item.reasoning_summary_format : null,
-            support_verbosity: typeof item.support_verbosity === "boolean" ? item.support_verbosity : null,
-            default_verbosity: typeof item.default_verbosity === "string" ? item.default_verbosity : null
-        });
-    }
-    return Array.from(deduped.values()).sort((a, b) => compareModelSlugs(a.slug, b.slug));
-}
-function isFresh(cache, now) {
-    return now - cache.fetchedAt < CACHE_TTL_MS;
-}
-async function withCacheLock(cacheDir, fn) {
-    return withLockedDirectory(cacheDir, fn, { staleMs: 10_000 });
-}
-async function readCatalogFromDisk(cacheDir, accountId) {
-    return withCacheLock(cacheDir, async () => {
-        const file = cachePath(cacheDir, accountId);
-        const parsed = await readJsonFileBestEffort(file);
-        if (!isRecord(parsed))
-            return undefined;
-        if (typeof parsed.fetchedAt !== "number")
-            return undefined;
-        const models = parseCatalogResponse({ models: parsed.models });
-        return {
-            fetchedAt: parsed.fetchedAt,
-            models
-        };
-    });
-}
-async function readCatalogFromOpencodeCache(cacheDir) {
-    try {
-        const entries = await fs.readdir(cacheDir);
-        const candidates = entries.filter((name) => {
-            return isCodexModelsCacheFileName(name);
-        });
-        if (candidates.length === 0)
-            return undefined;
-        let best;
-        for (const fileName of candidates) {
-            const parsed = await readJsonFileBestEffort(path.join(cacheDir, fileName));
-            if (!isRecord(parsed))
-                continue;
-            const models = parseCatalogResponse({ models: parsed.models });
-            if (models.length === 0)
-                continue;
-            const fetchedAt = typeof parsed.fetchedAt === "number" ? parsed.fetchedAt : 0;
-            if (!best || fetchedAt > best.fetchedAt) {
-                best = {
-                    fetchedAt,
-                    models
-                };
-            }
-        }
-        return best;
-    }
-    catch (error) {
-        if (!isFsErrorCode(error, "ENOENT")) {
-            // Best effort fallback discovery.
-        }
-        return undefined;
-    }
-}
-function parseFetchedAtFromUnknown(value) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === "string") {
-        const parsed = Date.parse(value);
-        if (!Number.isNaN(parsed)) {
-            return parsed;
-        }
-    }
-    return 0;
-}
-async function readCatalogFromCodexCliCache() {
-    const file = path.join(os.homedir(), ".codex", "models_cache.json");
-    const parsed = await readJsonFileBestEffort(file);
-    if (!isRecord(parsed))
-        return undefined;
-    const models = parseCatalogResponse({ models: parsed.models });
-    if (models.length === 0)
-        return undefined;
-    return {
-        fetchedAt: parseFetchedAtFromUnknown(parsed.fetched_at ?? parsed.fetchedAt),
-        models
-    };
-}
-async function writeCatalogToDisk(cacheDir, accountId, cache) {
-    await withCacheLock(cacheDir, async () => {
-        const primaryFile = cachePath(cacheDir, accountId);
-        const compatFile = opencodeShardCachePath(cacheDir, accountId);
-        const files = compatFile ? [primaryFile, compatFile] : [primaryFile];
-        for (const file of files) {
-            await writeJsonFileBestEffort(file, cache);
-        }
-    }).catch((error) => {
-        if (error instanceof Error) {
-            // Best effort cache persistence.
-        }
-        // Best effort cache persistence.
-    });
-}
-function emitEvent(input, event) {
-    try {
-        input.onEvent?.({
-            ...event,
-            scope: input.accountId?.trim() ? "account" : "shared"
-        });
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            // Keep catalog path side-effect free even if observer callback throws.
-        }
-        // Keep catalog path side-effect free.
-    }
-}
-function deriveReason(value) {
-    if (value instanceof Error) {
-        return value.name || "error";
-    }
-    return "error";
-}
-function emitStaleCacheFallback(input, fallback) {
-    if (fallback.disk) {
-        emitEvent(input, { type: "stale_cache_used", reason: "network_fetch_failed" });
-        return fallback.disk.models;
-    }
-    if (fallback.opencode) {
-        emitEvent(input, { type: "stale_cache_used", reason: "opencode_cache_fallback" });
-        return fallback.opencode.models;
-    }
-    if (fallback.codexCli) {
-        emitEvent(input, { type: "stale_cache_used", reason: "codex_cli_cache_fallback" });
-        return fallback.codexCli.models;
-    }
-    return undefined;
-}
-function normalizeClientVersion(value, fallback) {
-    const trimmed = value?.trim();
-    if (trimmed)
-        return trimmed;
-    const fallbackTrimmed = fallback?.trim();
-    return fallbackTrimmed || DEFAULT_CLIENT_VERSION;
-}
-function buildModelsEndpoint(clientVersion) {
-    const separator = CODEX_MODELS_ENDPOINT.includes("?") ? "&" : "?";
-    return `${CODEX_MODELS_ENDPOINT}${separator}client_version=${encodeURIComponent(clientVersion)}`;
-}
-export async function getCodexModelCatalog(input) {
-    const now = (input.now ?? Date.now)();
-    const cacheDir = resolveCodexCacheDir(input.cacheDir);
-    const key = cacheKey(cacheDir, input.accountId);
-    const fetchImpl = input.fetchImpl ?? fetch;
-    const accessToken = input.accessToken?.trim();
-    const targetClientVersion = normalizeSemver(input.clientVersion) ?? normalizeSemver(input.versionHeader);
-    const defaultGithubModelsRefresh = Boolean(accessToken) && input.fetchImpl === undefined && targetClientVersion !== undefined;
-    const shouldRefreshGithubModelsCache = input.refreshGithubModelsCache ?? defaultGithubModelsRefresh;
-    if (shouldRefreshGithubModelsCache) {
-        await refreshSharedGitHubModelsCache({
-            cacheDir,
-            targetClientVersion,
-            now,
-            fetchImpl
-        });
-    }
-    const memory = inMemoryCatalog.get(key);
-    const allowMemoryHit = !memory?.staleFallback || !accessToken;
-    if (memory && !input.forceRefresh && isFresh(memory, now) && allowMemoryHit) {
-        emitEvent(input, { type: "memory_cache_hit" });
-        return memory.models;
-    }
-    const disk = await readCatalogFromDisk(cacheDir, input.accountId);
-    const hasFreshDisk = !!disk && isFresh(disk, now);
-    if (hasFreshDisk && !input.forceRefresh) {
-        inMemoryCatalog.set(key, disk);
-        emitEvent(input, { type: "disk_cache_hit" });
-        return disk.models;
-    }
-    let opencodeCacheFallback;
-    let codexCliCacheFallback;
-    const ensureFallbackCaches = async () => {
-        if (opencodeCacheFallback !== undefined || codexCliCacheFallback !== undefined)
-            return;
-        opencodeCacheFallback = await readCatalogFromOpencodeCache(cacheDir);
-        codexCliCacheFallback = await readCatalogFromCodexCliCache();
-    };
-    if (!accessToken) {
-        await ensureFallbackCaches();
-        if (disk) {
-            emitEvent(input, { type: "stale_cache_used", reason: "missing_access_token" });
-            inMemoryCatalog.set(key, disk);
-            return disk.models;
-        }
-        const stale = emitStaleCacheFallback(input, {
-            opencode: opencodeCacheFallback,
-            codexCli: codexCliCacheFallback
-        });
-        if (stale) {
-            inMemoryCatalog.set(key, {
-                fetchedAt: now,
-                models: stale,
-                staleFallback: true
-            });
-            return stale;
-        }
-        emitEvent(input, { type: "catalog_unavailable", reason: "missing_access_token" });
-        return undefined;
-    }
-    const headers = {
-        authorization: `Bearer ${accessToken}`,
-        originator: input.originator?.trim() || "opencode"
-    };
-    const clientVersion = normalizeClientVersion(input.clientVersion, input.versionHeader);
-    const versionHeader = normalizeClientVersion(input.versionHeader, input.clientVersion);
-    if (versionHeader)
-        headers.version = versionHeader;
-    const userAgent = input.userAgent?.trim();
-    if (userAgent)
-        headers["user-agent"] = userAgent;
-    const betaValue = input.openaiBeta?.trim();
-    if (betaValue)
-        headers["openai-beta"] = betaValue;
-    const accountId = input.accountId?.trim() || undefined;
-    if (accountId) {
-        headers["chatgpt-account-id"] = accountId;
-    }
-    const existingInFlight = inFlightCatalogFetches.get(key);
-    if (existingInFlight) {
-        return existingInFlight;
-    }
-    const inFlight = (async () => {
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-            let response;
-            try {
-                const endpoint = buildModelsEndpoint(clientVersion);
-                response = await fetchImpl(endpoint, {
-                    method: "GET",
-                    headers,
-                    signal: controller.signal
-                });
-            }
-            finally {
-                clearTimeout(timeout);
-            }
-            if (!response.ok) {
-                throw new Error(`codex models request failed with status ${response.status}`);
-            }
-            const payload = (await response.json());
-            const models = parseCatalogResponse(payload);
-            if (models.length === 0) {
-                throw new Error("codex models response did not contain usable models");
-            }
-            const nextCache = {
-                fetchedAt: now,
-                models
-            };
-            inMemoryCatalog.set(key, nextCache);
-            await writeCatalogToDisk(cacheDir, accountId, nextCache);
-            emitEvent(input, { type: "network_fetch_success" });
-            return nextCache.models;
-        }
-        catch (error) {
-            emitEvent(input, { type: "network_fetch_failed", reason: deriveReason(error) });
-            await ensureFallbackCaches();
-            const stale = emitStaleCacheFallback(input, {
-                disk,
-                opencode: opencodeCacheFallback,
-                codexCli: codexCliCacheFallback
-            });
-            if (stale) {
-                inMemoryCatalog.set(key, {
-                    fetchedAt: now,
-                    models: stale,
-                    staleFallback: true
-                });
-                return stale;
-            }
-            emitEvent(input, { type: "catalog_unavailable", reason: "network_fetch_failed" });
-            return undefined;
-        }
-    })();
-    inFlightCatalogFetches.set(key, inFlight);
-    return inFlight.finally(() => {
-        if (inFlightCatalogFetches.get(key) === inFlight) {
-            inFlightCatalogFetches.delete(key);
-        }
-    });
-}
-function cloneModelTemplate(template, slug) {
-    const cloned = { ...template };
-    setModelIdentityFields(cloned, slug);
-    return cloned;
-}
-function formatModelDisplayNameFromSlug(slug) {
-    const tokens = slug
-        .trim()
-        .split("-")
-        .map((part) => part.trim())
-        .filter((part) => part.length > 0);
-    if (tokens.length === 0)
-        return slug;
-    const words = tokens.map((token) => {
-        if (token.toLowerCase() === "gpt")
-            return "GPT";
-        if (token.length === 1)
-            return token.toUpperCase();
-        return `${token.charAt(0).toUpperCase()}${token.slice(1).toLowerCase()}`;
-    });
-    if (words[0] === "GPT" && words.length > 1) {
-        return [`${words[0]}-${words[1]}`, ...words.slice(2)].join(" ");
-    }
-    return words.join(" ");
-}
-function setModelIdentityFields(model, slug) {
-    const display = formatModelDisplayNameFromSlug(slug);
-    for (const key of ["id", "slug", "model"]) {
-        model[key] = slug;
-    }
-    for (const key of ["name", "displayName", "display_name"]) {
-        model[key] = display;
-    }
-}
-function resolvePersonalityText(model, personality) {
-    const vars = model.model_messages?.instructions_variables;
-    const normalized = (personality ?? "none").trim().toLowerCase();
-    if (!normalized)
-        return undefined;
-    if (normalized !== "none") {
-        const fromFile = resolveCustomPersonalityDescription(normalized);
-        if (typeof fromFile === "string" && fromFile.trim()) {
-            return fromFile;
-        }
-    }
-    if (!vars)
-        return undefined;
-    if (vars.personalities && typeof vars.personalities === "object") {
-        const fromMap = vars.personalities[normalized] ?? vars.personalities.default;
-        if (typeof fromMap === "string" && fromMap.trim()) {
-            return fromMap;
-        }
-    }
-    if (normalized === "friendly" && typeof vars.personality_friendly === "string" && vars.personality_friendly.trim()) {
-        return vars.personality_friendly;
-    }
-    if (normalized === "pragmatic" &&
-        typeof vars.personality_pragmatic === "string" &&
-        vars.personality_pragmatic.trim()) {
-        return vars.personality_pragmatic;
-    }
-    if (typeof vars.personality_default === "string" && vars.personality_default.trim()) {
-        return vars.personality_default;
-    }
-    if (typeof vars.personality === "string" && vars.personality.trim()) {
-        return vars.personality;
-    }
-    return undefined;
-}
-function isCompatibleInstructionsText(value) {
-    if (UNRESOLVED_TEMPLATE_MARKER_REGEX.test(value))
-        return false;
-    return !STALE_BRIDGE_MARKERS.some((pattern) => pattern.test(value));
-}
-function normalizeSafeInstructions(value) {
-    if (!value)
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    return isCompatibleInstructionsText(trimmed) ? trimmed : undefined;
-}
-export function resolveInstructionsForModel(model, personality) {
-    const template = model.model_messages?.instructions_template?.trim();
-    const base = model.base_instructions?.trim();
-    const safeBase = normalizeSafeInstructions(base);
-    if (!template)
-        return safeBase;
-    if (!template.includes("{{") && !template.includes("}}")) {
-        return normalizeSafeInstructions(template) ?? safeBase;
-    }
-    const personalityText = resolvePersonalityText(model, personality) ?? "";
-    const rendered = template
-        .replace(/\{\{\s*personality\s*\}\}/gi, personalityText)
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
-    return normalizeSafeInstructions(rendered) ?? safeBase;
-}
-function resolveAllowedSlugs(catalogModels, fallback) {
-    const preferred = (catalogModels ?? []).map((model) => model.slug).filter((slug) => slug.length > 0);
-    if (preferred.length > 0) {
-        return Array.from(new Set(preferred)).sort(compareModelSlugs);
-    }
-    return Array.from(new Set(fallback.map((slug) => slug.trim().toLowerCase()).filter(Boolean))).sort(compareModelSlugs);
-}
-function resolveTemplateSource(providerModels) {
-    for (const candidate of ["gpt-5.3-codex", "gpt-5.2-codex", "gpt-5.1-codex", "gpt-5.2"]) {
-        const found = providerModels[candidate];
-        if (found)
-            return found;
-    }
-    const first = Object.values(providerModels)[0];
-    return first;
-}
-function stripEffortSuffix(slug) {
-    return slug.replace(EFFORT_SUFFIX_REGEX, "");
-}
-function ensureModelOptions(model) {
-    const existing = model.options;
-    if (isRecord(existing))
-        return existing;
-    const options = {};
-    model.options = options;
-    return options;
-}
-function findModelBySlug(catalogModels, slug) {
-    if (!catalogModels || catalogModels.length === 0)
-        return undefined;
-    const normalized = slug.trim().toLowerCase();
-    const exact = catalogModels.find((item) => item.slug === normalized);
-    if (exact)
-        return exact;
-    const base = stripEffortSuffix(normalized);
-    return catalogModels.find((item) => item.slug === base);
-}
-export function getRuntimeDefaultsForModel(model) {
-    if (!model)
-        return undefined;
-    const out = {};
-    if (typeof model.apply_patch_tool_type === "string") {
-        const next = model.apply_patch_tool_type.trim();
-        if (next)
-            out.applyPatchToolType = next;
-    }
-    const defaultReasoningEffort = normalizeReasoningEffort(model.default_reasoning_level);
-    if (defaultReasoningEffort) {
-        out.defaultReasoningEffort = defaultReasoningEffort;
-    }
-    const supportedReasoningEfforts = Array.from(new Set((model.supported_reasoning_levels ?? [])
-        .map((level) => normalizeReasoningEffort(level.effort))
-        .filter((value) => value !== undefined)));
-    if (supportedReasoningEfforts.length > 0) {
-        out.supportedReasoningEfforts = supportedReasoningEfforts;
-    }
-    if (typeof model.supports_reasoning_summaries === "boolean") {
-        out.supportsReasoningSummaries = model.supports_reasoning_summaries;
-    }
-    if (typeof model.reasoning_summary_format === "string") {
-        const next = model.reasoning_summary_format.trim();
-        if (next)
-            out.reasoningSummaryFormat = next;
-    }
-    if (typeof model.support_verbosity === "boolean") {
-        out.supportsVerbosity = model.support_verbosity;
-    }
-    const defaultVerbosity = normalizeVerbosity(model.default_verbosity);
-    if (defaultVerbosity) {
-        out.defaultVerbosity = defaultVerbosity;
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-export function getRuntimeDefaultsForSlug(slug, catalogModels) {
-    const model = findModelBySlug(catalogModels, slug);
-    return getRuntimeDefaultsForModel(model);
-}
-export function applyCodexCatalogToProviderModels(input) {
-    const allowedSlugs = resolveAllowedSlugs(input.catalogModels, input.fallbackModels);
-    const allowed = new Set(allowedSlugs);
-    const bySlug = new Map((input.catalogModels ?? []).map((model) => [model.slug, model]));
-    const templateSource = resolveTemplateSource(input.providerModels);
-    for (const slug of allowedSlugs) {
-        if (!input.providerModels[slug]) {
-            if (templateSource) {
-                input.providerModels[slug] = cloneModelTemplate(templateSource, slug);
-            }
-            else {
-                input.providerModels[slug] = { id: slug, model: slug };
-            }
-        }
-        else {
-            setModelIdentityFields(input.providerModels[slug], slug);
-        }
-        const catalogModel = bySlug.get(slug);
-        const options = ensureModelOptions(input.providerModels[slug]);
-        if (catalogModel) {
-            const instructions = resolveInstructionsForModel(catalogModel, input.personality);
-            options.codexCatalogModel = catalogModel;
-            if (instructions) {
-                input.providerModels[slug].instructions = instructions;
-                options.codexInstructions = instructions;
-            }
-            else {
-                delete options.codexInstructions;
-            }
-        }
-        else {
-            delete options.codexCatalogModel;
-        }
-        const runtimeDefaults = getRuntimeDefaultsForSlug(slug, input.catalogModels);
-        if (runtimeDefaults) {
-            input.providerModels[slug].codexRuntimeDefaults = runtimeDefaults;
-            options.codexRuntimeDefaults = runtimeDefaults;
-        }
-        else {
-            delete input.providerModels[slug].codexRuntimeDefaults;
-            delete options.codexRuntimeDefaults;
-        }
-    }
-    for (const modelId of Object.keys(input.providerModels)) {
-        if (!allowed.has(modelId)) {
-            delete input.providerModels[modelId];
-        }
-    }
-    const orderedModelIds = Object.keys(input.providerModels).sort((a, b) => b.localeCompare(a));
-    if (orderedModelIds.length > 1) {
-        const orderedEntries = orderedModelIds.map((modelId) => [modelId, input.providerModels[modelId]]);
-        for (const modelId of Object.keys(input.providerModels)) {
-            delete input.providerModels[modelId];
-        }
-        for (const [modelId, model] of orderedEntries) {
-            if (model) {
-                input.providerModels[modelId] = model;
-            }
-        }
-    }
-    for (const model of Object.values(input.providerModels)) {
-        model.cost = {
-            input: 0,
-            output: 0,
-            cache: { read: 0, write: 0 }
-        };
-    }
-}
+export { CACHE_TTL_MS, CODEX_GITHUB_MODELS_URL_PREFIX, CODEX_MODELS_ENDPOINT, compareModelSlugs, compareSemver, DEFAULT_CLIENT_VERSION, EFFORT_SUFFIX_REGEX, FETCH_TIMEOUT_MS, githubModelsTag, githubModelsUrl, isRecord, normalizeModelSlug, normalizeReasoningEffort, normalizeSemver, normalizeVerbosity, parseCatalogResponse, parseFetchedAtFromUnknown, parseReasoningLevels, parseSemver, semverFromTag } from "./model-catalog/shared.js";
+export { getCodexModelCatalog } from "./model-catalog/catalog-fetch.js";
+export { applyCodexCatalogToProviderModels, getRuntimeDefaultsForModel, getRuntimeDefaultsForSlug, resolveInstructionsForModel } from "./model-catalog/provider.js";
 //# sourceMappingURL=model-catalog.js.map