fix: handle changes to supportsModelTypeTags (#14160)

_Requested by **Simon P** · [Slack
thread](https://comfy-organization.slack.com/archives/C0BLBR8S6RL/p1785303856496099?thread_ts=1785303856.496099&cid=C0BLBR8S6RL)_

**Scope narrowed following review from Simon P**: this PR now ships only
the approved fix — hardening `refreshRemoteConfig`'s error handling and
sourcing `supportsModelTypeTags` from it directly. The OSS
reconnect/visibility-trigger scope from the original proposal is
deliberately cut (see below).

## What changed

`refreshRemoteConfig` used to wipe `remoteConfig`/`window.__CONFIG__` to
`{}` on *any* fetch failure, including a transient network blip or the
bootstrap fetch's own abort-on-timeout. Every flag sourced from
`remoteConfig` would flap to its default for the rest of that tick, and
anything that reads `window.__CONFIG__` directly (`dialogService.ts`,
`useSubscription.ts`, `useSettingUI.ts`) would momentarily see no config
at all.

- **Before**: fetch throws (network error, `AbortError`) →
`remoteConfig.value = {}` and `window.__CONFIG__ = {}` → every
remote-config-backed flag drops to its default until the next successful
poll.
- **After**: fetch throws → log and mark `remoteConfigState = 'error'`,
but leave `remoteConfig.value` and `window.__CONFIG__` at their
last-known-good value.
- **Unchanged**: a 401/403 response still clears both — that's a real
auth-state transition, not a blip, and downstream flags should reflect
the logged-out state immediately.

Because `refreshRemoteConfig` no longer flaps on transient errors,
`supportsModelTypeTags` can now be sourced the same way as every other
server flag:

```ts
get supportsModelTypeTags() {
  return resolveFlag(
    ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS,
    remoteConfig.value.supports_model_type_tags,
    false
  )
}
```

`useModelTypeTagsRefresh.ts` (bespoke fetch + zod schema + single-flight
+ timeout + its own reconnect/visibility/interval triggers) and its test
file are deleted outright — nothing replaces them. `modelStore.ts`'s
existing watcher on `flags.supportsModelTypeTags` is untouched; it still
reloads the model library when the flag flips, just fed by
`remoteConfig` now instead of the deleted composable's ref.

The cloud-only 600s poller in `cloudRemoteConfig.ts` (gated behind
`isCloud` at the `extensions/core/index.ts` import site) is unchanged —
still cloud-only, no reconnect/visibility triggers added anywhere.

## Why the OSS/reconnect scope was cut

The original proposal additionally added reconnect- and visibility-based
refresh triggers for OSS/non-cloud builds. That's dropped here because
the asset-API model listing this flag governs isn't reachable off-cloud
today:

- `Comfy.Assets.UseAssetAPI` defaults to `false` off-cloud and is marked
`experimental: true`
(`src/platform/settings/constants/coreSettings.ts`).
- `Comfy.ModelLibrary.UseAssetBrowser` likewise defaults to `false`
off-cloud and is `experimental: true`.
- The asset-browser code paths that actually consume the tagging flag
are hard-gated on cloud, e.g. `assetService.ts`'s `usesAssetApi()` (`if
(!isCloud) return false`) and `useMediaAssetActions.ts` (`if (!isCloud)
{ ... }`).

An OSS user has to opt into an experimental, off-by-default setting
before this flag matters at all, and even then the asset-browser surface
stays inert off-cloud. Adding reconnect/visibility plumbing for a path
that's unreachable in practice isn't worth the extra surface area; it
can be revisited if/when the asset API ships for OSS. Consolidating the
two `/features` pollers was already tracked in
[FE-1439](https://linear.app/comfyorg/issue/FE-1439/consolidate-duplicate-apifeatures-pollers-refreshremoteconfig)
— this PR is that consolidation, minus the OSS trigger scope.

## Test plan

- `refreshRemoteConfig.test.ts`: the two error-handling tests are
rewritten (`retains the last-known-good config when the request aborts`,
`retains the last-known-good config on a transient fetch error`) to
assert retention instead of clearing; the 401/403-clears and
500-preserves tests are unchanged.
- `useFeatureFlags.test.ts`: `supportsModelTypeTags` tests rewritten to
the same shape as other `resolveFlag`-backed flags (remote-config value
wins, falls back to the server feature, defaults false).
- `modelStore.test.ts`: the capability-change tests now drive
`remoteConfig.value` instead of the deleted composable's ref; same
reload-on-flip/no-reload-on-legacy-path assertions.
- `pnpm typecheck`, `pnpm lint`, and the targeted suite
(`refreshRemoteConfig.test.ts`, `useFeatureFlags.test.ts`,
`modelStore.test.ts`) all pass — 88/88 tests.

## Net effect

Deletes `useModelTypeTagsRefresh.ts` and its test file and simplifies
`supportsModelTypeTags` to a one-line `resolveFlag` call: 9 files
changed, 29 insertions(+), 410 deletions(-).

---
_Generated by [Claude Code](https://claude.ai/code)_

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Austin Mroz <austin@comfy.org>

Author: 3 people

src/composables/useFeatureFlags.test.ts

@@ -410,6 +410,47 @@ describe('useFeatureFlags', () => {
     })
   })
 
+  describe('supportsModelTypeTags', () => {
+    afterEach(() => {
+      remoteConfig.value = {}
+    })
+
+    it('uses the remote config value', () => {
+      remoteConfig.value = { supports_model_type_tags: true }
+
+      const { flags } = useFeatureFlags()
+
+      expect(flags.supportsModelTypeTags).toBe(true)
+    })
+
+    it('falls back to the server feature flag when remote config omits it', () => {
+      vi.mocked(api.getServerFeature).mockImplementation(
+        (path, defaultValue) => {
+          if (path === ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS) return true
+          return defaultValue
+        }
+      )
+
+      const { flags } = useFeatureFlags()
+
+      expect(flags.supportsModelTypeTags).toBe(true)
+      expect(api.getServerFeature).toHaveBeenCalledWith(
+        ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS,
+        false
+      )
+    })
+
+    it('defaults to false when neither source has the flag', () => {
+      vi.mocked(api.getServerFeature).mockImplementation(
+        (_path, defaultValue) => defaultValue
+      )
+
+      const { flags } = useFeatureFlags()
+
+      expect(flags.supportsModelTypeTags).toBe(false)
+    })
+  })
+
   describe('churnkeyAppId', () => {
     afterEach(() => {
       vi.mocked(distributionTypes).isCloud = false

src/composables/useFeatureFlags.ts

@@ -249,8 +249,9 @@ export function useFeatureFlags() {
       )
     },
     get supportsModelTypeTags() {
-      return api.getServerFeature(
+      return resolveFlag(
         ServerFeatureFlag.SUPPORTS_MODEL_TYPE_TAGS,
+        remoteConfig.value.supports_model_type_tags,
         false
       )
     },

src/platform/remoteConfig/types.ts

@@ -111,6 +111,7 @@ export type RemoteConfig = {
   partner_node_governance_enabled?: boolean
   user_secrets_enabled?: boolean
   node_library_essentials_enabled?: boolean
+  supports_model_type_tags?: boolean
   free_tier_credits?: number
   free_tier_balance?: {
     allowance: number

src/stores/modelStore.test.ts

@@ -1,8 +1,10 @@
 import { createTestingPinia } from '@pinia/testing'
 import { setActivePinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
 
 import { assetService } from '@/platform/assets/services/assetService'
+import { remoteConfig } from '@/platform/remoteConfig/remoteConfig'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { api } from '@/scripts/api'
 import {
@@ -27,6 +29,9 @@ vi.mock('@/scripts/api', () => ({
   api: {
     getModels: vi.fn(),
     getModelFolders: vi.fn(),
+    getServerFeature: vi.fn(
+      (_path: string, defaultValue?: unknown) => defaultValue
+    ),
     viewMetadata: vi.fn(),
     apiURL: vi.fn((path: string) => `http://localhost:8188${path}`),
     addEventListener: vi.fn(),
@@ -110,6 +115,7 @@ describe('useModelStore', () => {
     setActivePinia(createTestingPinia({ stubActions: false }))
     vi.resetAllMocks()
     isCloudRef.value = false
+    remoteConfig.value = {}
   })
 
   it('should load models', async () => {
@@ -599,6 +605,59 @@ describe('useModelStore', () => {
     })
   })
 
+  describe('model-type capability change', () => {
+    it('rebuilds the library when the capability turns on', async () => {
+      enableMocks(true)
+      store = useModelStore()
+      await store.loadModelFolders()
+      await store.getLoadedModelFolder('checkpoints')
+      expect(api.getModelFolders).toHaveBeenCalledTimes(1)
+      expect(assetService.getAssetModels).toHaveBeenCalledTimes(1)
+
+      remoteConfig.value = { supports_model_type_tags: true }
+
+      await vi.waitFor(() => {
+        expect(api.getModelFolders).toHaveBeenCalledTimes(2)
+        expect(assetService.getAssetModels).toHaveBeenCalledTimes(2)
+      })
+      expect(assetService.invalidateModelBuckets).toHaveBeenCalled()
+      expect(assetService.seedModelAssets).not.toHaveBeenCalled()
+    })
+
+    it('rebuilds again when the capability rolls back', async () => {
+      enableMocks(true)
+      remoteConfig.value = { supports_model_type_tags: true }
+      store = useModelStore()
+      await store.loadModelFolders()
+      await store.getLoadedModelFolder('checkpoints')
+      expect(api.getModelFolders).toHaveBeenCalledTimes(1)
+      expect(assetService.getAssetModels).toHaveBeenCalledTimes(1)
+
+      remoteConfig.value = { supports_model_type_tags: false }
+
+      await vi.waitFor(() => {
+        expect(api.getModelFolders).toHaveBeenCalledTimes(2)
+        expect(assetService.getAssetModels).toHaveBeenCalledTimes(2)
+      })
+      expect(assetService.invalidateModelBuckets).toHaveBeenCalled()
+    })
+
+    it('does not reload on the legacy listing path', async () => {
+      enableMocks(false)
+      store = useModelStore()
+      await store.loadModelFolders()
+      await store.getLoadedModelFolder('checkpoints')
+      expect(api.getModelFolders).toHaveBeenCalledTimes(1)
+
+      remoteConfig.value = { supports_model_type_tags: true }
+
+      await nextTick()
+      await nextTick()
+      expect(api.getModelFolders).toHaveBeenCalledTimes(1)
+      expect(assetService.invalidateModelBuckets).not.toHaveBeenCalled()
+    })
+  })
+
   describe('visibleModelFolders', () => {
     it('hides folders that loaded empty in asset mode', async () => {
       enableMocks(true)

src/stores/modelStore.ts

@@ -1,7 +1,8 @@
 import { debounce } from 'es-toolkit'
 import { defineStore } from 'pinia'
-import { computed, onScopeDispose, ref } from 'vue'
+import { computed, onScopeDispose, ref, watch } from 'vue'
 
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import type { ModelFile } from '@/platform/assets/schemas/assetSchema'
 import { assetService } from '@/platform/assets/services/assetService'
 import { isCloud } from '@/platform/distribution/types'
@@ -532,6 +533,20 @@ export const useModelStore = defineStore('models', () => {
     unsubscribeModelsScanned()
   })
 
+  const { flags } = useFeatureFlags()
+
+  watch(
+    () => flags.supportsModelTypeTags,
+    () =>
+      usesAssetApi() &&
+      reloadModels().catch((error) => {
+        console.error(
+          'Failed to reload the model library after a capability change',
+          error
+        )
+      })
+  )
+
   return {
     models,
     modelFolders,