@fonlan/dsh-model-router 0.3.1 → 0.3.4

package/src/client/settings-card.css

@@ -327,3 +327,144 @@
   line-height: 16px;
   padding: 0 8px;
 }
+
+/* ── model display order ────────────────────────────────────────────────── */
+
+.mr-sort {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 8px 10px;
+  border: 1px solid var(--dsw-alias-border-inverted);
+  border-radius: 10px;
+  background: var(--dsw-alias-bg-module-platform);
+}
+
+.mr-sort-head {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.mr-sort-title {
+  color: var(--dsw-alias-label-primary);
+  font-size: 13px;
+  line-height: 20px;
+}
+
+.mr-sort-desc {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 12px;
+  line-height: 18px;
+}
+
+.mr-sort-modes {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.mr-sort-mode {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  border: 1px solid transparent;
+  border-radius: 8px;
+  padding: 5px 6px;
+  cursor: pointer;
+}
+
+.mr-sort-mode:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+.mr-sort-mode input[type="radio"] {
+  margin-top: 2px;
+  accent-color: var(--dsw-alias-accent);
+}
+
+.mr-sort-mode-copy {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  min-width: 0;
+}
+
+.mr-sort-mode-label {
+  color: var(--dsw-alias-label-primary);
+  font-size: 13px;
+  line-height: 20px;
+}
+
+.mr-sort-mode-desc {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 12px;
+  line-height: 18px;
+}
+
+.mr-sort-custom {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  border-top: 1px solid var(--dsw-alias-border-l2, #2a3346);
+  padding-top: 8px;
+}
+
+.mr-sort-hint {
+  color: var(--dsw-alias-label-caption);
+  margin: 0;
+  font-size: 11px;
+  line-height: 16px;
+}
+
+.mr-sort-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  max-height: 280px;
+  overflow-y: auto;
+}
+
+.mr-sort-item {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  border: 1px solid var(--dsw-alias-border-l2, #2a3346);
+  border-radius: 8px;
+  padding: 4px 8px 4px 4px;
+  background: var(--dsw-alias-bg-layer-1, #0d1017);
+}
+
+.mr-sort-item-drop {
+  border-color: var(--dsw-alias-border-brand);
+}
+
+.mr-sort-item-busy {
+  opacity: 0.6;
+  pointer-events: none;
+}
+
+.mr-sort-model-name {
+  color: var(--dsw-alias-label-primary);
+  font-size: 13px;
+  line-height: 20px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  overflow: hidden;
+  min-width: 0;
+}
+
+.mr-sort-model-id {
+  color: var(--dsw-alias-label-tertiary);
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 11px;
+  line-height: 16px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  overflow: hidden;
+  flex: 1;
+  text-align: right;
+}

package/src/client/settings-card.tsx

@@ -16,13 +16,14 @@
  * mutation controls.
  */
 import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react'
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
+import type { Context } from '@deepseek-ai/cordis'
+type ClientContext = Context
 import type { Translate } from '@deepseek-ai/dsh-client-ui-slots'
 import { LOCALE_NS } from './locales'
-import { api, type ModelRouterState, type RouterModelView } from './api'
+import { api, type ModelRouterState, type ModelSortMode, type RouterModelView } from './api'
 import './settings-card.css'
 
-/** Client settings scope face (subset of @deepseek-ai/dsh-client-runtime). */
+/** Client settings scope face (subset of the app client modules). */
 export interface SettingsScopeFace {
   getSnapshot(): {
     status: 'loading' | 'ready' | 'unavailable'
@@ -93,6 +94,8 @@ export function makeSettingsCard(ctx: ClientContext): (props: SettingsCardProps)
     const [drag, setDrag] = useState<{ modelId: string; index: number } | null>(null)
     const [quickSwitchBusy, setQuickSwitchBusy] = useState(false)
     const [ignorePrefixBusy, setIgnorePrefixBusy] = useState(false)
+    const [sortBusy, setSortBusy] = useState(false)
+    const [modelDrag, setModelDrag] = useState<{ index: number } | null>(null)
 
     const load = useCallback(async () => {
       setLoading(true)
@@ -177,6 +180,41 @@ export function makeSettingsCard(ctx: ClientContext): (props: SettingsCardProps)
       }
     }, [state])
 
+    const changeModelSort = useCallback(async (mode: ModelSortMode) => {
+      if (state === null || state.modelSort === mode) return
+      const previous = state.modelSort
+      setState(prev => prev === null ? prev : { ...prev, modelSort: mode })
+      setSortBusy(true)
+      try {
+        setState(await api.setModelSort(mode))
+        setError(null)
+      } catch (cause) {
+        setState(prev => prev === null ? prev : { ...prev, modelSort: previous })
+        setError(t('sortFailed', { message: cause instanceof Error ? cause.message : String(cause) }))
+      } finally {
+        setSortBusy(false)
+      }
+    }, [state, t])
+
+    const moveModel = useCallback(async (from: number, to: number) => {
+      if (state === null || from === to) return
+      // The drag list shows the full display order (modelOrder + catalog
+      // tail); persist the whole reordered id list as the new custom order.
+      const ids = state.models.map(model => model.id)
+      const order = arrayMove(ids, from, to)
+      setState(prev => prev === null ? prev : { ...prev, modelOrder: order })
+      setSortBusy(true)
+      try {
+        setState(await api.setModelOrder(order))
+        setError(null)
+      } catch (cause) {
+        setState(prev => prev === null ? prev : { ...prev, modelOrder: state.modelOrder })
+        setError(t('sortFailed', { message: cause instanceof Error ? cause.message : String(cause) }))
+      } finally {
+        setSortBusy(false)
+      }
+    }, [state, t])
+
     // The namespace is served by the host once the scope is ready. While it is
     // merely loading, keep the card mounted (the tab already dispatched it);
     // if it is unavailable (deployment without the host half), render nothing.
@@ -235,6 +273,77 @@ export function makeSettingsCard(ctx: ClientContext): (props: SettingsCardProps)
                   <span className="mr-quick-switch-desc">{t('ignorePrefixDescription')}</span>
                 </span>
               </label>
+              <div className="mr-sort">
+                <div className="mr-sort-head">
+                  <span className="mr-sort-title">{t('sortTitle')}</span>
+                  <span className="mr-sort-desc">{t('sortDescription')}</span>
+                </div>
+                <div className="mr-sort-modes" role="radiogroup" aria-label={t('sortTitle')}>
+                  {(['custom', 'name', 'recent'] as const).map(mode => (
+                    <label key={mode} className="mr-sort-mode">
+                      <input
+                        type="radio"
+                        name="mr-model-sort"
+                        checked={state?.modelSort === mode}
+                        disabled={loading || sortBusy || !writable}
+                        onChange={() => void changeModelSort(mode)}
+                      />
+                      <span className="mr-sort-mode-copy">
+                        <span className="mr-sort-mode-label">{t(`sortMode${mode[0].toUpperCase()}${mode.slice(1)}`)}</span>
+                        <span className="mr-sort-mode-desc">{t(`sortModeDesc${mode[0].toUpperCase()}${mode.slice(1)}`)}</span>
+                      </span>
+                    </label>
+                  ))}
+                </div>
+                {state?.modelSort === 'custom' && (
+                  <div className="mr-sort-custom">
+                    <p className="mr-sort-hint">{t('sortCustomHint')}</p>
+                    <ol className="mr-sort-list">
+                      {models.map((model, index) => {
+                        const dropTarget = modelDrag !== null && modelDrag.index !== index
+                        return (
+                          <li
+                            key={model.id}
+                            className={[
+                              'mr-sort-item',
+                              dropTarget ? 'mr-sort-item-drop' : '',
+                              sortBusy ? 'mr-sort-item-busy' : '',
+                            ].filter(Boolean).join(' ')}
+                            draggable={!sortBusy && writable}
+                            onDragStart={(event) => {
+                              setModelDrag({ index })
+                              event.dataTransfer.effectAllowed = 'move'
+                              try {
+                                event.dataTransfer.setData('text/plain', model.id)
+                              } catch {
+                                // drag data is cosmetic for our own handler
+                              }
+                            }}
+                            onDragOver={(event) => {
+                              if (modelDrag !== null && modelDrag.index !== index) {
+                                event.preventDefault()
+                                event.dataTransfer.dropEffect = 'move'
+                              }
+                            }}
+                            onDrop={(event) => {
+                              if (modelDrag !== null && modelDrag.index !== index) {
+                                event.preventDefault()
+                                moveModel(modelDrag.index, index)
+                              }
+                              setModelDrag(null)
+                            }}
+                            onDragEnd={() => setModelDrag(null)}
+                          >
+                            <span className="mr-grip" aria-hidden="true">⠿</span>
+                            <span className="mr-sort-model-name">{model.name}</span>
+                            <span className="mr-sort-model-id">{model.id}</span>
+                          </li>
+                        )
+                      })}
+                    </ol>
+                  </div>
+                )}
+              </div>
               <div className="mr-toolbar">
                 <span className="mr-count">{t('modelsCount', { count: models.length })}</span>
                 <button type="button" className="mr-button" onClick={() => void load()} disabled={loading}>

package/src/server/adapter.ts

@@ -13,12 +13,14 @@ import type {
   LlmModelInfo,
   LlmProviderInfo,
   LlmResolvedModelInfo,
+  PreparedAdapterCall,
   StreamChunk,
 } from '@deepseek-ai/dsh-llm'
 import {
   displayProvider,
   resolveActive,
   ROUTER_PROVIDER_ID,
+  sortModelsForList,
   stripModelIdPrefix,
   type MergedModel,
   type RouterConfigShape,
@@ -34,6 +36,8 @@ export interface RouterFacts {
   providerNames(): ReadonlyMap<string, string>
   /** The LLM runtime to delegate to. */
   llm(): LlmRuntime
+  /** Record one model request for the recent-use ordering (fire-and-forget). */
+  noteModelUsed(modelId: string): void
 }
 
 /** One resolved route for a model id. */
@@ -76,6 +80,27 @@ export function entryRawId(merged: MergedModel, providerId: string): string {
   return merged.providers.find(provider => provider.provider === providerId)?.id ?? merged.id
 }
 
+/** One validated route plus the merged model it was resolved against. */
+export interface BoundRoute {
+  route: ResolvedRoute
+  merged: MergedModel
+}
+
+function unroutable(model: string): LlmError {
+  return new LlmError(`model-router: no provider serves model "${model}"`, 'NO_ADAPTER')
+}
+
+/**
+ * Resolve one model id to its active provider and merged model, rejecting
+ * unadvertised or currently unroutable ids before any provider I/O.
+ */
+export function bindRoute(facts: RouterFacts, modelId: string): BoundRoute {
+  const merged = mergedFor(facts, modelId)
+  const route = merged === null ? null : routeFor(facts, modelId)
+  if (merged === null || route === null) throw unroutable(modelId)
+  return { route, merged }
+}
+
 export class ModelRouterAdapter extends LlmAdapter {
   constructor(private readonly facts: RouterFacts) {
     super()
@@ -86,10 +111,11 @@ export class ModelRouterAdapter extends LlmAdapter {
   }
 
   async listModels(_provider: string): Promise<readonly LlmModelInfo[]> {
+    const config = this.facts.config()
     const { models } = this.facts.catalog()
     const names = this.facts.providerNames()
     const out: LlmModelInfo[] = []
-    for (const merged of models) {
+    for (const merged of sortModelsForList(models, config)) {
       const route = routeFor(this.facts, merged.id)
       const display = displayProvider(merged, route?.provider)
       if (display === null) continue
@@ -104,14 +130,35 @@ export class ModelRouterAdapter extends LlmAdapter {
   }
 
   async resolveModel(_provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo> {
-    const route = routeFor(this.facts, model)
-    const merged = route === null ? null : mergedFor(this.facts, model)
-    if (route === null || merged === null) {
-      throw new LlmError(`model-router: no provider serves model "${model}"`, 'NO_ADAPTER')
+    const { route, merged } = bindRoute(this.facts, model)
+    return this.resolveRoutedIdentity(route, merged, signal)
+  }
+
+  /**
+   * Bind the route generation at preparation time: a provider switch or
+   * catalog refresh between preparation and dispatch cannot combine one
+   * generation's metadata with another's endpoint, matching the host's
+   * one-generation dispatch contract.
+   */
+  async prepareCall(_provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall> {
+    const { route, merged } = bindRoute(this.facts, model)
+    return {
+      model: await this.resolveRoutedIdentity(route, merged, signal),
+      stream: (options: GenerateOptions) => this.streamRouted(options, route, merged),
     }
-    // Delegate with the provider's raw local id (it may carry a vendor/
-    // prefix the real provider needs), then normalize the resolved identity
-    // back to the merged display id so sessions/metering never leak prefixes.
+  }
+
+  async *stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
+    const { route, merged } = bindRoute(this.facts, options.model)
+    yield* this.streamRouted(options, route, merged)
+  }
+
+  /**
+   * Delegate with the provider's raw local id (it may carry a vendor/
+   * prefix the real provider needs), then normalize the resolved identity
+   * back to the merged display id so sessions/metering never leak prefixes.
+   */
+  private async resolveRoutedIdentity(route: ResolvedRoute, merged: MergedModel, signal?: AbortSignal): Promise<LlmResolvedModelInfo> {
     const resolved = await this.facts.llm().resolveModelInfo(route.provider, entryRawId(merged, route.provider), signal)
     const display = displayProvider(merged, route.provider)
     return {
@@ -122,11 +169,13 @@ export class ModelRouterAdapter extends LlmAdapter {
     }
   }
 
-  async *stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
-    const route = routeFor(this.facts, options.model)
-    const merged = route === null ? null : mergedFor(this.facts, options.model)
-    if (route === null || merged === null) {
-      throw new LlmError(`model-router: no provider serves model "${options.model}"`, 'NO_ADAPTER')
+  private async *streamRouted(options: GenerateOptions, route: ResolvedRoute, merged: MergedModel): AsyncIterable<StreamChunk> {
+    // Record the use for the recent-use model ordering; never blocks or
+    // fails the request (the service debounces persistence).
+    try {
+      this.facts.noteModelUsed(merged.id)
+    } catch {
+      // advisory only
     }
     // In-process delegation: the inner call resolves the real adapter and
     // runs its full pipeline (retry, waterfall, replay-state stripping). The

package/src/server/rpc.ts

@@ -150,6 +150,22 @@ export function registerApiRoutes(ctx: Context, service: ModelRouterService): ()
     return service.state()
   })
 
+  route('set-model-sort', async (p) => {
+    if (p.mode !== 'custom' && p.mode !== 'name' && p.mode !== 'recent') {
+      throw new Error('mode 必须是 custom、name 或 recent')
+    }
+    await service.setModelSort(p.mode)
+    return service.state()
+  })
+
+  route('set-model-order', async (p) => {
+    if (!Array.isArray(p.order) || !p.order.every((id): id is string => typeof id === 'string')) {
+      throw new Error('order 必须是模型 id 数组')
+    }
+    await service.setModelOrder(p.order)
+    return service.state()
+  })
+
   return () => {
     for (const dispose of disposers) dispose()
   }

package/src/server/service.ts

@@ -5,7 +5,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
-import { settingsNamespace, type SettingsScope } from '@deepseek-ai/dsh-settings'
+import type { SettingsScope } from '@deepseek-ai/dsh-settings'
 import type { AdapterRegistrationHandle } from '@deepseek-ai/dsh-llm'
 import {
   initialConfigFor,
@@ -16,12 +16,14 @@ import {
   resolveActive,
   setActive,
   setOrder,
+  sortModelsForList,
+  type ModelSortMode,
   type RouterConfigShape,
 } from '../shared/config.js'
 import { buildCatalog, type RouterCatalog } from './catalog.js'
 import { ModelRouterAdapter, type RouterFacts } from './adapter.js'
 
-export const NS = settingsNamespace(ROUTER_SETTINGS_NS)
+export const NS = ROUTER_SETTINGS_NS
 
 /** Settings document schema: one entry per model id. */
 export const RouterConfigSchema: z<RouterConfigShape> = z.object({
@@ -33,16 +35,30 @@ export const RouterConfigSchema: z<RouterConfigShape> = z.object({
   // Schemastery object keys are input-optional, so absent is valid here.
   showQuickSwitch: z.boolean(),
   ignoreModelIdPrefix: z.boolean(),
+  modelSort: z.union([z.const('custom'), z.const('name'), z.const('recent')]),
+  modelOrder: z.array(z.string()),
+  recentlyUsed: z.dict(z.number()),
 })
 
-const EMPTY_CONFIG: RouterConfigShape = { models: {}, showQuickSwitch: true, ignoreModelIdPrefix: true }
+const EMPTY_CONFIG: RouterConfigShape = {
+  models: {},
+  showQuickSwitch: true,
+  ignoreModelIdPrefix: true,
+  modelSort: 'custom',
+  modelOrder: [],
+  recentlyUsed: {},
+}
 
 /** The settings-page state view served by the API. */
 export interface ModelRouterState {
-  /** Whether the composer quick route-switcher button is enabled. */
+  /** Whether provider switching is shown inside the composer model picker menu. */
   showQuickSwitch: boolean
   /** Whether model ids are matched with their leading vendor/ prefix ignored. */
   ignoreModelIdPrefix: boolean
+  /** The model-list display order mode (custom | name | recent). */
+  modelSort: ModelSortMode
+  /** Explicit model id order for custom mode (display order). */
+  modelOrder: string[]
   providers: Array<{ id: string; name: string; credentialConfigured: boolean }>
   models: Array<{
     id: string
@@ -73,6 +89,12 @@ export class ModelRouterService implements RouterFacts {
   /** How long a built catalog is considered fresh before being rebuilt. */
   private readonly catalogTtlMs = 30_000
 
+  /** Debounced recent-use persistence (see noteModelUsed / flushUsage). */
+  private readonly usageFlushMs = 1_500
+  private usageDebounce: ReturnType<typeof setTimeout> | null = null
+  private pendingUsage: Record<string, number> = {}
+  private usageFlushRunning = false
+
   constructor(ctx: Context) {
     this.ctx = ctx
   }
@@ -99,6 +121,14 @@ export class ModelRouterService implements RouterFacts {
   }
 
   stop(): void {
+    // Flush any pending recent-use writes before the scope is torn down.
+    if (this.usageDebounce !== null) {
+      clearTimeout(this.usageDebounce)
+      this.usageDebounce = null
+    }
+    if (Object.keys(this.pendingUsage).length > 0) {
+      void this.flushUsage()
+    }
     this.registration?.()
     this.registration = undefined
   }
@@ -126,6 +156,45 @@ export class ModelRouterService implements RouterFacts {
     return this.ctx.llm
   }
 
+  /**
+   * Record one model request for the `recent` display order. Fire-and-forget
+   * (the adapter never awaits it): timestamps accumulate in memory and are
+   * persisted debounced, so a burst of requests coalesces into one settings
+   * write.
+   */
+  noteModelUsed(modelId: string): void {
+    if (this.scope === undefined) return
+    this.pendingUsage[modelId] = Date.now()
+    if (this.usageDebounce !== null) return
+    this.usageDebounce = setTimeout(() => {
+      this.usageDebounce = null
+      void this.flushUsage()
+    }, this.usageFlushMs)
+  }
+
+  /** Persist accumulated usage timestamps (merging with any concurrent writes). */
+  private async flushUsage(): Promise<void> {
+    if (this.usageFlushRunning) return
+    this.usageFlushRunning = true
+    const pending = this.pendingUsage
+    this.pendingUsage = {}
+    try {
+      if (this.scope === undefined || Object.keys(pending).length === 0) return
+      const current = this.config()
+      await this.scope.replace({
+        ...current,
+        recentlyUsed: { ...current.recentlyUsed, ...pending },
+      })
+    } catch (error) {
+      // Re-queue the failed batch so a transient write failure does not lose
+      // usage history; the next request retries it.
+      this.pendingUsage = { ...pending, ...this.pendingUsage }
+      this.ctx.logger.warn(`model-router: usage persist failed: ${error instanceof Error ? error.message : String(error)}`)
+    } finally {
+      this.usageFlushRunning = false
+    }
+  }
+
   // ── catalog lifecycle ────────────────────────────────────────────────────
 
   /**
@@ -166,13 +235,13 @@ export class ModelRouterService implements RouterFacts {
     const catalog = await this.refreshCatalog(true)
     if (this.scope === undefined) return
     const current = this.config()
-    const { models, changed } = reconcileConfig(current, catalog.models)
+    const { models, modelOrder, changed } = reconcileConfig(current, catalog.models)
     if (!changed) return
     try {
       await this.scope.replace({
+        ...current,
         models,
-        showQuickSwitch: current.showQuickSwitch,
-        ignoreModelIdPrefix: current.ignoreModelIdPrefix,
+        ...(modelOrder === undefined ? {} : { modelOrder }),
       })
     } catch (error) {
       this.ctx.logger.warn(`model-router: reconcile persist failed: ${error instanceof Error ? error.message : String(error)}`)
@@ -197,12 +266,14 @@ export class ModelRouterService implements RouterFacts {
     return {
       showQuickSwitch: config.showQuickSwitch,
       ignoreModelIdPrefix: config.ignoreModelIdPrefix,
+      modelSort: config.modelSort,
+      modelOrder: config.modelOrder,
       providers: catalog.providers.map(provider => ({
         id: provider.id,
         name: names.get(provider.id) ?? provider.id,
         credentialConfigured: creds.get(provider.id) ?? true,
       })),
-      models: catalog.models.map((model) => {
+      models: sortModelsForList(catalog.models, config).map((model) => {
         const ids = model.providers.map(provider => provider.provider)
         const stored = config.models[model.id] ?? initialConfigFor(ids)
         const active = resolveActive(config, model.id, ids)
@@ -253,11 +324,7 @@ export class ModelRouterService implements RouterFacts {
     }
     const current = this.config()
     if (current.showQuickSwitch === value) return
-    await this.scope.replace({
-      models: current.models,
-      showQuickSwitch: value,
-      ignoreModelIdPrefix: current.ignoreModelIdPrefix,
-    })
+    await this.scope.replace({ ...current, showQuickSwitch: value })
   }
 
   /**
@@ -272,23 +339,47 @@ export class ModelRouterService implements RouterFacts {
     }
     const current = this.config()
     if (current.ignoreModelIdPrefix === value) return
-    await this.scope.replace({
-      models: current.models,
-      showQuickSwitch: current.showQuickSwitch,
-      ignoreModelIdPrefix: value,
-    })
+    await this.scope.replace({ ...current, ignoreModelIdPrefix: value })
     await this.refreshAndReconcile()
   }
 
+  /** Switch the model-list display order mode (global, persisted). */
+  async setModelSort(mode: ModelSortMode): Promise<void> {
+    if (this.scope === undefined) {
+      throw new Error('model-router: settings service is not available in this profile')
+    }
+    const current = this.config()
+    if (current.modelSort === mode) return
+    await this.scope.replace({ ...current, modelSort: mode })
+  }
+
+  /**
+   * Replace the explicit custom model order (global, persisted). Vanished
+   * ids are pruned and missing catalog models appended, so the stored order
+   * always covers the live catalog.
+   */
+  async setModelOrder(order: string[]): Promise<void> {
+    if (this.scope === undefined) {
+      throw new Error('model-router: settings service is not available in this profile')
+    }
+    await this.refreshCatalog()
+    const ids = new Set(this.cached.models.map(model => model.id))
+    const clean = order.filter(id => ids.has(id))
+    for (const model of this.cached.models) {
+      if (!clean.includes(model.id)) clean.push(model.id)
+    }
+    const current = this.config()
+    const sameOrder = clean.length === current.modelOrder.length
+      && clean.every((id, at) => id === current.modelOrder[at])
+    if (sameOrder) return
+    await this.scope.replace({ ...current, modelOrder: clean })
+  }
+
   private async persist(models: Record<string, { order: string[]; active: string }>): Promise<void> {
     if (this.scope === undefined) {
       throw new Error('model-router: settings service is not available in this profile')
     }
     const current = this.config()
-    await this.scope.replace({
-      models,
-      showQuickSwitch: current.showQuickSwitch,
-      ignoreModelIdPrefix: current.ignoreModelIdPrefix,
-    })
+    await this.scope.replace({ ...current, models })
   }
 }