UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

549 lines (522 loc) • 30.9 kB
import { randomUUID } from "node:crypto"; import { captureInitialSelectionBaseline, finalizeInitialModelSelection } from "../../providers/initial-model-selection-runtime"; import { captureModelDiscoveryBaseline, finalizeModelDiscovery, projectSupersededModelDiscovery } from "../../providers/new-model-policy-runtime"; import { CatalogGatherBusyError } from "../../codex/catalog/routed-gather"; import { observeModelCacheRevision, readableSupersededModelDiscovery } from "../../codex/model-cache"; import { initialModelSelectionPending } from "../../providers/initial-model-selection"; import { isPassiveRead } from "../../lib/passive-read"; import { readFileSync } from "node:fs"; import type { CatalogModel } from "../../codex/catalog"; import { catalogModelSlug, invalidateCodexModelsCache, nativeModelRows, uniqueCatalogModelsForPublicList } from "../../codex/catalog"; import { DEFAULT_SUBAGENT_MODELS, codexAutoStartEnabled, hasOwnProvider, isValidProviderName, multiAgentGuidanceEnabled, providerBaseUrlConfigError, providerHeadersConfigError, saveConfigPreservingClaudeCode, } from "../../config"; import { clearLoginState, getLoginStatus, isPublicOAuthProvider, listOAuthProviders, startLoginFlow, submitManualLoginCode, upsertOAuthProvider, } from "../../oauth"; import { removeCredential } from "../../oauth/store"; import { providerDestinationResolvedError } from "../../lib/destination-policy"; import { enrichProviderFromCatalog, listKeyLoginProviders } from "../../oauth/key-providers"; import { deriveProviderPresets } from "../../providers/derive"; import { providerCodexAccountMode } from "../../providers/registry"; import { routedSlug, slugEquals } from "../../providers/slug-codec"; import { clearProviderQuotaCache, fetchProviderQuotaReports } from "../../providers/quota"; import { isCanonicalOpenAiForwardProvider, OPENAI_CODEX_PROVIDER_ID } from "../../providers/openai-tiers"; import { clearThreadAccountMap } from "../../codex/routing"; import { primeCodexPoolQuotas } from "../../codex/auth-api"; import { DEFAULT_PROVIDER_CONTEXT_CAP, globalContextCapValue, providerContextCap, providerContextCaps, setAllProviderContextCaps, setGlobalContextCapValue, setProviderContextCap } from "../../providers/context-cap"; import { resolveCodexHomeDir } from "../../codex/home"; import { isKnownRequestFailureCause, isKnownRequestFailureStage, readUsageEntries } from "../../usage/log"; import { getUsageDebugLogEntries } from "../../usage/debug"; import { cacheObservationFromUsage } from "../../usage/cache-provenance"; import { parseRange, parseUsageSurface, summarizeUsage } from "../../usage/summary"; import { stripCodexRuntimeProviderFields } from "../../codex/auth-context"; import { getProviderRegistryEntry, providerMatchesRegistryTransport } from "../../providers/registry"; import { getDebugLogEntries } from "../../lib/debug-log-buffer"; import { resendPermission } from "../../lib/request-failure-model"; import { getInjectionDebugLogEntries } from "../../lib/injection-debug-log"; import { clearDebugSettings, clearDebugSetting, getDebugSettings, setDebugSettings, type DebugFlag, } from "../../lib/debug-settings"; import type { OcxClaudeCodeConfig, OcxClaudeDesktopProfile, OcxConfig, OcxCustomModel, OcxProviderConfig, OcxUsage } from "../../types"; import type { DesktopProfileModel } from "../../claude/desktop-profile"; import { drainAndShutdown } from "../lifecycle"; import { filterRequestLogs, getRequestLogEntries, type RequestLogEntry } from "../request-log"; import { creditChargeUnrepresentable, estimateAttemptCost, estimateComboCost, estimateRequestCost, serviceTierContext, normalizeCostTokens, tokensPerSecond } from "../../usage/cost"; import { costTokensWithinBound, isRepresentableCreditCount } from "../../usage/credit-billing"; import type { PersistedUsageAttempt } from "../../usage/log"; import { usageModelPriceOptions } from "../../usage/model-identity"; import { isAllowedRequestOrigin, jsonResponse, providerManagementConfigError, publicProviderBaseUrl, safeConfigDTO } from "../auth-cors"; import { applySystemEnvToggle } from "../system-env"; export function isPlainRecord(v: unknown): v is Record<string, unknown> { return typeof v === "object" && v !== null && !Array.isArray(v); } export function parseDebugLogQuery(url: URL): { after: number; limit: number } { const after = Number(url.searchParams.get("after") ?? url.searchParams.get("since") ?? "0"); const limit = Number(url.searchParams.get("limit") ?? "500"); return { after: Number.isFinite(after) && after > 0 ? after : 0, limit: Number.isFinite(limit) && limit > 0 ? Math.min(limit, 2000) : 500, }; } // ---- /api/logs display metrics (devlog/_plan/260720_toks_speed_price_columns/020) ---- // Derived at response time only; NEVER persisted to the request log or usage.jsonl. export type MetricUnavailableReason = | "usage_missing" | "usage_unsupported" | "output_missing" | "invalid_duration" | "price_unmatched" | "invalid_cache_breakdown" | "invalid_usage" | "combo_attempt_unavailable" | "ttft_missing" | "decode_window_missing" | "decode_window_too_short" // The row is credit-priced, but `providerCredits x creditPriceUsd` cannot be represented (an // out-of-bound price or credit count, or an overflowing product). It is deliberately not // `price_unmatched`-with-a-token-estimate: falling back would report a different amount than // the credit basis the operator configured. | "credit_cost_unrepresentable"; export type TokPerSecondResult = | { kind: "value"; value: number; estimated: boolean } | { kind: "unavailable"; reason: MetricUnavailableReason }; export type DecodeTimingBasis = "generation-window" | "legacy-post-visible-output"; export type DecodeTokPerSecondResult = | (Extract<TokPerSecondResult, { kind: "value" }> & { timingBasis: DecodeTimingBasis }) | Extract<TokPerSecondResult, { kind: "unavailable" }>; export type CostEstimateReason = | "usage_estimated" | "cache_detail_missing" | "expected_price_overlay" | "provider_cost_overlay" | "priority_lower_bound"; export type CostResult = | { kind: "value"; estimate: NonNullable<ReturnType<typeof estimateRequestCost>>; estimateReasons: CostEstimateReason[] } | { kind: "partial"; subtotalUsd: number; unpricedAttempts: number } | { kind: "unavailable"; reason: MetricUnavailableReason }; export type MetricSource = Pick<RequestLogEntry, "provider" | "model" | "durationMs" | "firstOutputMs" | "genStartMs" | "lastOutputMs" | "protocolTrace" | "usageStatus" | "usage" | "requestedServiceTier" | "configuredServiceTier" | "responseServiceTier" | "tierOutcome" | "routeDecision" | "cacheProvenance"> & { attempts?: readonly PersistedUsageAttempt[]; }; export function tokPerSecondResult(entry: Pick<MetricSource, "durationMs" | "usageStatus" | "usage">): TokPerSecondResult { if (!entry.usage) return { kind: "unavailable", reason: "usage_missing" }; if (entry.usageStatus === "unsupported") return { kind: "unavailable", reason: "usage_unsupported" }; const value = tokensPerSecond(entry.usage.outputTokens, entry.durationMs); if (value === null) { return { kind: "unavailable", reason: entry.usage.outputTokens <= 0 ? "output_missing" : "invalid_duration", }; } return { kind: "value", value, estimated: entry.usageStatus === "estimated" || entry.usage.estimated === true }; } /** * Shortest post-TTFT window that can carry a decode-rate estimate (#4038). * * Below one second the window is dominated by things that are not decoding: TTFT jitter, the * proxy's own buffering, and the granularity of the timestamps themselves. A 240-token response * whose first token arrived 50 ms before the last one is not a 4800 tok/s model, and printing * that number is worse than printing nothing — which is precisely why the earlier attempt at * this metric (#4040) was closed as an unreliable estimate. */ export const MIN_DECODE_WINDOW_MS = 1_000; /** * Estimated DECODE throughput: output tokens over the measured output window (#4038): the generation window when * recorded, otherwise the window after the first token. * * Strictly additive. `tokensPerSecond` and `tokPerSecondResult` are untouched, rows only gain the * optional window pair, and the end-to-end rate beside it keeps meaning exactly what it * has always meant — it is documented as end-to-end, so this is a missing metric rather than a * miscalculated one. * * Always `estimated: true`. The proxy's TTFT is when the FIRST BYTE reached the proxy, which is * not the provider's own generation start, so this can never be more than an estimate no matter * how long the window is. Saying so in the payload is the honest half of the answer to #4040; * MIN_DECODE_WINDOW_MS is the other half. * * When the row carries the generation window (`genStartMs` / `lastOutputMs`, #6309) that window is * used instead. `firstOutputMs` is the first VISIBLE delta, so on a reasoning model the post-TTFT * window leaves out the reasoning phase while `outputTokens` still counts its tokens; the * generation window spans both and stops at the last delta rather than at stream close. */ export function decodeTokPerSecondResult( entry: Pick<MetricSource, "durationMs" | "firstOutputMs" | "genStartMs" | "lastOutputMs" | "protocolTrace" | "usageStatus" | "usage">, ): DecodeTokPerSecondResult { if (!entry.usage) return { kind: "unavailable", reason: "usage_missing" }; if (entry.usageStatus === "unsupported") return { kind: "unavailable", reason: "usage_unsupported" }; if (entry.usage.outputTokens <= 0) return { kind: "unavailable", reason: "output_missing" }; const { genStartMs, lastOutputMs } = entry; if (genStartMs !== undefined && lastOutputMs !== undefined && Number.isFinite(genStartMs) && Number.isFinite(lastOutputMs)) { const generationMs = lastOutputMs - genStartMs; if (generationMs <= 0) return { kind: "unavailable", reason: "invalid_duration" }; if (generationMs < MIN_DECODE_WINDOW_MS) return { kind: "unavailable", reason: "decode_window_too_short" }; const value = tokensPerSecond(entry.usage.outputTokens, generationMs); return value === null ? { kind: "unavailable", reason: "invalid_duration" } : { kind: "value", value, estimated: true, timingBasis: "generation-window" }; } if (entry.protocolTrace?.inbound === "gemini") return { kind: "unavailable", reason: "decode_window_missing" }; // A row that predates TTFT capture, or a non-streaming turn that never recorded one, has no // window to measure. That is a different fact from a bad duration, so it gets its own reason. if (entry.firstOutputMs === undefined) return { kind: "unavailable", reason: "ttft_missing" }; if (!Number.isFinite(entry.firstOutputMs) || entry.firstOutputMs < 0 || !Number.isFinite(entry.durationMs)) { return { kind: "unavailable", reason: "invalid_duration" }; } const windowMs = entry.durationMs - entry.firstOutputMs; // TTFT at or past the total duration means the two clocks disagree; there is no window. if (windowMs <= 0) return { kind: "unavailable", reason: "invalid_duration" }; if (windowMs < MIN_DECODE_WINDOW_MS) return { kind: "unavailable", reason: "decode_window_too_short" }; const value = tokensPerSecond(entry.usage.outputTokens, windowMs); if (value === null) return { kind: "unavailable", reason: "invalid_duration" }; return { kind: "value", value, estimated: true, timingBasis: "legacy-post-visible-output" }; } /** * True when the row would otherwise be priced but its credit charge cannot be represented. A row * with no resolved token price is unpriced for the ordinary reason, so the price lookup has to * succeed before the credit failure is the explanation. */ function isCreditCostUnrepresentable(entry: MetricSource): boolean { if (entry.attempts?.length) { return entry.attempts.some(attempt => creditChargeUnrepresentable({ ...attempt, ...usageModelPriceOptions(entry, attempt), })); } return creditChargeUnrepresentable({ ...entry, ...usageModelPriceOptions(entry, entry) }); } export function unavailableCostReason(entry: MetricSource): MetricUnavailableReason { // Normalizer-first classification: the landed normalizer recovers legacy // cachedInputTokens=read+write rows via retry, so a raw read+write>input // pre-check would misclassify recoverable rows (020 audit blocker #2). if (!entry.usage && !entry.attempts?.length) return "usage_missing"; if (entry.usageStatus === "unsupported") return "usage_unsupported"; // A Combo is unpriced when ANY attempt is, and the generic reason covers every other cause. // An attempt whose credit charge cannot be represented is a different fact: the operator set a // credit price and the row cannot honor it, so the parent names that instead of implying an // ordinary missing price somewhere in the attempt list. if (entry.attempts?.length) { return isCreditCostUnrepresentable(entry) ? "credit_cost_unrepresentable" : "combo_attempt_unavailable"; } if (!entry.usage) return "usage_missing"; if (isCreditCostUnrepresentable(entry)) return "credit_cost_unrepresentable"; const tokens = normalizeCostTokens(entry.usage); if (!tokens) { const effectiveRead = entry.usage.cacheReadInputTokens ?? entry.usage.cachedInputTokens ?? 0; const effectiveWrite = entry.usage.cacheCreationInputTokens ?? 0; const finite = [entry.usage.inputTokens, entry.usage.outputTokens, effectiveRead, effectiveWrite] .every(v => Number.isFinite(v) && v >= 0); return finite ? "invalid_cache_breakdown" : "invalid_usage"; } // A finite but absurd token count normalizes fine and then overflows the estimate. Calling that // "price unmatched" would send an operator to the price table for a number no price can fix. if (!costTokensWithinBound(tokens)) return "invalid_usage"; return "price_unmatched"; } /** Display-time cost estimate for one log entry (or its attempt list), including the reasons that qualify the estimate. */ export function costResult(entry: MetricSource): CostResult { const tier = serviceTierContext(entry); const attempts = entry.attempts?.map(attempt => ({ ...attempt, ...usageModelPriceOptions(entry, attempt), cacheProvenance: attempt.cacheProvenance ?? entry.cacheProvenance, })); const estimate = attempts?.length ? estimateComboCost(attempts, undefined, tier) : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier, ...usageModelPriceOptions(entry, entry) }); if (!estimate) { // Keep the shared request-total contract. Native Gemini credential replays can show a // separate subtotal from the attempts for which we do have a price. if (entry.protocolTrace?.inbound === "gemini" && entry.protocolTrace.mode === "native" && attempts?.some(attempt => attempt.recoveryKinds.includes("oauth-401"))) { const priced = attempts.flatMap(attempt => estimateAttemptCost(attempt, undefined, tier) ?? []); const unpricedAttempts = attempts.length - priced.length; const subtotalUsd = priced.reduce((sum, attempt) => sum + attempt.cost.total, 0); if (priced.length && unpricedAttempts > 0 && Number.isFinite(subtotalUsd)) { return { kind: "partial", subtotalUsd, unpricedAttempts }; } } return { kind: "unavailable", reason: unavailableCostReason(entry) }; } // Provenance follows the basis that produced the amount. A credit charge is // `providerCredits x creditPriceUsd`; the token rates were resolved only to decide whether the // row falls back to them, so anything derived from those rates — a cache-detail caveat, a price // overlay, a Priority floor — describes a price nobody was charged. A `mixed` combo asks the // same question per attempt: only its token-priced legs may contribute token provenance, and // the parent's usage is a synthesized sum that priced nothing. const creditOnly = estimate.billing?.source === "provider-credits"; // `estimateComboCost` walks the attempts in order and fails closed on any unpriced leg, so the // estimate roster lines up with the stored one and the persisted cache provenance stays reachable. const tokenPricedLegs = estimate.billing?.source === "mixed" ? (estimate.attempts ?? []) .map((attempt, index) => ({ attempt, source: attempts?.[index] })) .filter(leg => leg.attempt.billing === undefined) : undefined; // A cost estimate is qualified by cache detail it can TRUST. A detail object that exists only // because a strict client requires the field carries no cache reading, so it qualifies the // estimate exactly as a missing one does — reading it as a measured zero prices the request // as an uncached send that nothing observed. const cacheDetailMissing = creditOnly ? false : tokenPricedLegs ? tokenPricedLegs.some(leg => cacheObservationFromUsage(leg.source?.usage, leg.source?.cacheProvenance).provenance !== "observed") : !!entry.usage && cacheObservationFromUsage(entry.usage, entry.cacheProvenance).provenance !== "observed"; const priceSources = creditOnly ? [] : tokenPricedLegs ? tokenPricedLegs.map(leg => leg.attempt.price.source) : [estimate.price?.source, ...(estimate.attempts?.map(attempt => attempt.price.source) ?? [])]; const estimateReasons = [ // The row's own usage reading still qualifies a credit charge: the credits came from it. entry.usageStatus === "estimated" || entry.usage?.estimated ? "usage_estimated" as const : undefined, cacheDetailMissing ? "cache_detail_missing" as const : undefined, priceSources.includes("expected") ? "expected_price_overlay" as const : undefined, priceSources.includes("user") ? "provider_cost_overlay" as const : undefined, estimate.priorityLowerBound ? "priority_lower_bound" as const : undefined, ].filter((reason): reason is CostEstimateReason => reason !== undefined); return { kind: "value", estimate, estimateReasons }; } /** * `/api/logs` row projection. * * `includeDecodeRate` exists because `/api/request-history` shares this DTO but not its * contract (#4038). The value would be meaningful there — `firstOutputMs` does survive into a * persisted-usage row — so this is a scope decision, not a correctness one: the decode rate is * a Logs-page metric, and widening a separate endpoint's response shape is not this change's * business. Flipping it on later is one argument. */ /** * Whether this proxy could have sent the row again, derived at READ time from the stage and * cause the recorder stored. * * Deliberately not persisted. The verdict is a function of two tables that this build owns, and * a row written months ago must not be able to assert a permission the current tables would * refuse -- the whole point of INV-RESEND-01 is that the refusal rules are one statement, and a * stored verdict would be a second one with no way to correct it. */ function resendVerdict(row: { failureStage?: string; failureCause?: string }): { resendPermission?: string } { if (!isKnownRequestFailureStage(row.failureStage) || !isKnownRequestFailureCause(row.failureCause)) return {}; return { resendPermission: resendPermission(row.failureStage, row.failureCause) }; } /** Keep invalid credit evidence available to cost estimation and omit it from API usage. */ export function publicLogUsage(usage: OcxUsage | undefined): { usage?: OcxUsage } { if (usage === undefined) return {}; const { providerCredits, ...rest } = usage; return { usage: isRepresentableCreditCount(providerCredits) ? usage : rest }; } export function requestLogDto( entry: RequestLogEntry, { includeDecodeRate = true }: { includeDecodeRate?: boolean } = {}, ): Record<string, unknown> { return { ...entry, ...publicLogUsage(entry.usage), ...(entry.attemptNormalizationDropped === true ? { attemptNormalizationDropped: true } : {}), ...resendVerdict(entry), displayMetrics: { tokPerSecond: tokPerSecondResult(entry), // The parent uses the REQUEST's own TTFT. A combo parent must not borrow an attempt's, // which would measure a window the parent never had. ...(includeDecodeRate ? { decodeTokPerSecond: decodeTokPerSecondResult(entry) } : {}), cost: costResult(entry), }, ...(entry.attempts?.length ? { attempts: entry.attempts.map(attempt => ({ ...attempt, ...publicLogUsage(attempt.usage), ...resendVerdict(attempt), displayMetrics: { tokPerSecond: tokPerSecondResult(attempt), // Each attempt measures its own attempt-relative TTFT. ...(includeDecodeRate ? { decodeTokPerSecond: decodeTokPerSecondResult(attempt) } : {}), cost: costResult({ ...attempt, attempts: undefined, routeDecision: entry.routeDecision, requestedServiceTier: entry.requestedServiceTier, configuredServiceTier: entry.configuredServiceTier, responseServiceTier: entry.responseServiceTier }), }, })), } : {}), }; } /** * Live routed-provider models for the proxy's /api/* and /v1/models endpoints. Delegates to the * canonical, TTL-cached `gatherRoutedModels` (single source of truth) — so the GUI/codex endpoints * share the same fetch, the same per-provider cache (dedups Codex's frequent /v1/models polling), * and the same stale fallback when a provider blips, instead of a parallel uncached copy. */ export async function fetchAllModels( config: OcxConfig, options: { /** Filled with each provider's content revision as of the moment its rows were chosen. */ providerContentRevisions?: Map<string, string>; /** The response renders visibility from this detached state. */ publishProjection?: (projection: OcxConfig) => void; allowSuperseded?: boolean; } = {}, ): Promise<CatalogModel[]> { // A Remote Link read: no upstream, no initial selection, no write (#6959). if (isPassiveRead()) return []; const { gatherRoutedModels } = await import("../../codex/catalog"); const baseline = captureInitialSelectionBaseline(config); const discoveryBaseline = captureModelDiscoveryBaseline(config); const revisions = options.providerContentRevisions ?? new Map<string, string>(); const outcomes: Array<{ provider: string; state: "authoritative" | "degraded" }> = []; const models = await gatherRoutedModels(config, { providerModelOutcomes: outcomes, providerContentRevisions: revisions, }); const authoritative = new Set(outcomes.filter(outcome => outcome.state === "authoritative").map(outcome => outcome.provider)); const superseded = [...revisions].filter(([provider, revision]) => observeModelCacheRevision(provider) !== revision); if (superseded.length > 0) { const { allowSuperseded, publishProjection } = options; if (!allowSuperseded || !publishProjection) throw new CatalogGatherBusyError(); for (const [provider, revision] of superseded) { const readable = readableSupersededModelDiscovery(provider, revision); if (readable === null) throw new CatalogGatherBusyError(); if (readable === "caller-local") authoritative.add(provider); } const projection = projectSupersededModelDiscovery(config, discoveryBaseline, models, [...authoritative]); if (!projection) throw new CatalogGatherBusyError(); publishProjection(projection); return models; } finalizeInitialModelSelection(config, baseline, uniqueCatalogModelsForPublicList(models), [...authoritative]); let publicationConfig = config; if (!finalizeModelDiscovery(config, discoveryBaseline, models, [...authoritative], revisions, projection => { publicationConfig = projection; options.publishProjection?.(projection); })) { throw new CatalogGatherBusyError(); } if (publicationConfig !== config && !options.publishProjection) { // Other consumers keep their live config, so only return rows visible under the projection. const { filterCatalogVisibleModels } = await import("../../codex/catalog"); return filterCatalogVisibleModels(models, publicationConfig); } return models; } export interface GrokCandidateModel { id: string; contextWindow?: number; native: boolean; } /** Configuration pickers may retain disabled choices, but never offer provisional models. */ export async function fetchInitializedModels(config: OcxConfig): Promise<CatalogModel[]> { return (await fetchAllModels(config)).filter(model => !initialModelSelectionPending(config.providers[model.provider])); } /** * The model list `syncGrokConfig` would inject, BEFORE the user's exclusions. The Grok * page needs this to show a switch for a model the user has already excluded — such a * model is absent from the fence, so readGrokStatus alone could never list it. Built * from the same two sources as the sync so the two can never disagree. */ export async function fetchGrokCandidateModels(config: OcxConfig): Promise<GrokCandidateModel[]> { const { filterCatalogVisibleModels, nativeContextLimits, nativeOpenAiContextWindow, visibleNativeSlugs } = await import("../../codex/catalog"); const routed = filterCatalogVisibleModels(await fetchAllModels(config), config); return [ ...visibleNativeSlugs(config).map(id => { const contextWindow = nativeOpenAiContextWindow(id, nativeContextLimits(config)); return { id, native: true, ...(contextWindow !== undefined ? { contextWindow } : {}) }; }), ...routed.map(m => ({ id: m.alias ?? `${m.provider}/${m.id}`, native: false, ...(m.contextWindow !== undefined ? { contextWindow: m.contextWindow } : {}), })), ]; } export function stripRegistryOnlyStaticHeaders(name: string, provider: OcxProviderConfig): OcxProviderConfig { const entry = providerMatchesRegistryTransport(name, provider) ? getProviderRegistryEntry(name) : undefined; if (!entry?.staticHeaders || !provider.headers) return provider; const headerEntries = Object.entries(provider.headers); const staticEntries = Object.entries(entry.staticHeaders); if (headerEntries.length !== staticEntries.length) return provider; const matchesRegistryStaticHeaders = staticEntries.every(([key, value]) => provider.headers?.[key] === value); if (!matchesRegistryStaticHeaders) return provider; const { headers: _headers, ...rest } = provider; return rest; } /** Shared Desktop profile DTO builder for the management API and CLI. */ export async function buildClaudeDesktopState(config: OcxConfig, stored?: OcxClaudeDesktopProfile) { const { filterCatalogVisibleModels, nativeContextLimits, nativeOpenAiContextWindow, desktopVisibleNativeSlugs } = await import("../../codex/catalog"); const { routeSupportsOneMillion } = await import("../../claude/long-context"); const { reconcileDesktopProfile, renderDesktopProfile } = await import("../../claude/desktop-profile"); const routed = filterCatalogVisibleModels(await fetchAllModels(config), config); const profileModels: DesktopProfileModel[] = [ // Native rows carry their real context window from the same accessor the Grok sync // uses — otherwise Sol's 372k and gpt-5.5's 272k render as blank on Desktop. ...desktopVisibleNativeSlugs(config).map(id => { const contextWindow = nativeOpenAiContextWindow(id, nativeContextLimits(config)); return { route: `native/${id}`, label: `${id} (native)`, ...(contextWindow !== undefined ? { contextWindow } : {}) }; }), ...routed.map(model => ({ route: `${model.provider}/${model.id}`, label: `${model.id} (${model.provider})`, ...(typeof model.contextWindow === "number" ? { contextWindow: model.contextWindow } : {}), })), ]; const profile = reconcileDesktopProfile(stored ?? config.claudeCode?.desktopProfile, profileModels); if (config.claudeCode?.desktopNativeModels === false) { for (const route of Object.keys(profile.assignments)) { if (route.startsWith("native/")) delete profile.assignments[route]; } for (const family of ["opus", "fable", "sonnet", "haiku"] as const) { const current = profile.defaults[family]; if (current?.startsWith("native/")) { profile.defaults[family] = Object.keys(profile.assignments) .filter(route => profile.assignments[route]?.family === family) .sort()[0] ?? null; } } } const available = new Set(profileModels.map(model => model.route)); const modelByRoute = new Map(profileModels.map(model => [model.route, model])); // Effort support: routed models with a non-empty reasoningEfforts ladder support effort; // native models always support it (Anthropic native effort). const effortByRoute = new Map<string, boolean>(); for (const m of routed) { effortByRoute.set(`${m.provider}/${m.id}`, Array.isArray(m.reasoningEfforts) && m.reasoningEfforts.length > 0); } for (const id of desktopVisibleNativeSlugs(config)) { effortByRoute.set(`native/${id}`, true); } const { desktopRouteVisible, filterDesktopModelsByVisibility, readDesktopModelVisibility } = await import("../../claude/desktop-model-visibility"); const visibility = readDesktopModelVisibility(config.claudeCode); const models = Object.keys(profile.assignments).sort().map(route => ({ route, label: modelByRoute.get(route)?.label ?? route, available: available.has(route), // Desktop list membership (#7702), separate from the tier assignment below. visible: desktopRouteVisible(visibility, route), ...(modelByRoute.get(route)?.contextWindow ? { contextWindow: modelByRoute.get(route)!.contextWindow } : {}), effortSupported: effortByRoute.get(route) ?? false, // Read-only view of the 1M capability the written Desktop config already emits, // derived from the SAME predicate so the dashboard chip can never disagree. supports1m: routeSupportsOneMillion(route, modelByRoute.get(route)?.contextWindow), assignment: profile.assignments[route]!, })); const rendered = renderDesktopProfile(profile, profileModels); const selected = filterDesktopModelsByVisibility( rendered.map(model => ({ ...model, anthropicFamilyTier: model.family })), rendered.map(model => model.route), visibility, ); // Match the writer's empty-selection fallback without changing the saved intent. const listed = selected.length > 0 ? selected : rendered; return { profile, models, rendered, visibility: visibility ?? null, // What the next apply writes, including generateDesktop3pModels' empty-selection fallback. listed: listed.map(({ route, name, label, family, isFamilyDefault }) => ({ route, name, label, family, isFamilyDefault: !!isFamilyDefault })), port: config.port, }; }