Function refreshModels

src/api/providers/fetchers/modelCache.ts:294–376

(options: GetModelsOptions)

 * @returns Fresh models from API, or existing cache if refresh yields worse data
 */
export const refreshModels = async (options: GetModelsOptions): Promise<ModelRecord> => {
	const { provider } = options
	const cacheKey = getCacheKey(options)

	const shouldSkipCache = isAuthScopedProvider(provider)

	// Check if there's already an in-flight refresh for this provider+url combination.
	// This prevents race conditions where multiple concurrent refreshes might
	// overwrite each other's results. Skip de-duplication for auth-scoped
	// providers because two concurrent calls may carry different tokens
	// (e.g., after a sign-out/sign-in within the same session) and we must
	// not return the first caller's results to the second caller.
	if (!shouldSkipCache) {
		const existingRequest = inFlightRefresh.get(cacheKey)
		if (existingRequest) {
			return existingRequest
		}
	}

	// Create the refresh promise and track it.
	//
	// The `finally` cleanup below runs only after the first `await` inside this async
	// function yields, which cannot happen until the current synchronous run -- including
	// the `inFlightRefresh.set(cacheKey, ...)` registration below -- has completed. So the
	// entry is always present in the map before `finally` can delete it; the registration
	// can never be lost to a microtask race even if the fetch resolves immediately.
	const refreshPromise = (async (): Promise<ModelRecord> => {
		try {
			// Force fresh API fetch - skip getModelsFromCache() check
			const models = await fetchModelsFromProvider(options)
			const modelCount = Object.keys(models).length

			// Get existing cached data for comparison
			const existingCache = shouldSkipCache ? undefined : getModelsFromCache(options)
			const existingCount = existingCache ? Object.keys(existingCache).length : 0

			if (modelCount === 0) {
				TelemetryService.instance.captureEvent(TelemetryEventName.MODEL_CACHE_EMPTY_RESPONSE, {
					provider,
					context: "refreshModels",
					hasExistingCache: existingCount > 0,
					existingCacheSize: existingCount,
				})
				if (existingCount > 0) {
					return existingCache!
				} else {
					return {}
				}
			}

			if (!shouldSkipCache) {
				memoryCache.set(cacheKey, models)

				await writeModels(cacheKey, models).catch((err) =>
					console.error(`[refreshModels] Error writing ${cacheKey} models to disk:`, err),
				)
			}