@fonlan/dsh-model-router 0.2.0 → 0.3.0

package/src/client/settings-section.tsx

@@ -59,6 +59,7 @@ export function makeSettingsSection(ctx: ClientContext): () => JSX.Element {
     const [busyModel, setBusyModel] = useState<string | null>(null)
     const [drag, setDrag] = useState<{ modelId: string; index: number } | null>(null)
     const [quickSwitchBusy, setQuickSwitchBusy] = useState(false)
+    const [ignorePrefixBusy, setIgnorePrefixBusy] = useState(false)
 
     const load = useCallback(async () => {
       setLoading(true)
@@ -127,6 +128,22 @@ export function makeSettingsSection(ctx: ClientContext): () => JSX.Element {
       }
     }, [state])
 
+    const toggleIgnorePrefix = useCallback(async (value: boolean) => {
+      if (state === null) return
+      const previous = state.ignoreModelIdPrefix
+      setState(prev => prev === null ? prev : { ...prev, ignoreModelIdPrefix: value })
+      setIgnorePrefixBusy(true)
+      try {
+        setState(await api.setIgnoreModelIdPrefix(value))
+        setError(null)
+      } catch (cause) {
+        setState(prev => prev === null ? prev : { ...prev, ignoreModelIdPrefix: previous })
+        setError(cause instanceof Error ? cause.message : String(cause))
+      } finally {
+        setIgnorePrefixBusy(false)
+      }
+    }, [state])
+
     const models = useMemo(() => state?.models ?? [], [state])
 
     return (
@@ -144,6 +161,18 @@ export function makeSettingsSection(ctx: ClientContext): () => JSX.Element {
             <span className="mr-quick-switch-desc">{t('showQuickSwitchDescription')}</span>
           </span>
         </label>
+        <label className="mr-quick-switch">
+          <input
+            type="checkbox"
+            checked={state?.ignoreModelIdPrefix ?? true}
+            disabled={loading || ignorePrefixBusy}
+            onChange={(event) => void toggleIgnorePrefix(event.target.checked)}
+          />
+          <span className="mr-quick-switch-copy">
+            <span className="mr-quick-switch-label">{t('ignorePrefixLabel')}</span>
+            <span className="mr-quick-switch-desc">{t('ignorePrefixDescription')}</span>
+          </span>
+        </label>
         <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

@@ -3,7 +3,9 @@
  * route `model-router`, it advertises the merged catalog and, at request time,
  * rewrites the provider field to the model's currently active provider and
  * delegates in-process to `ctx.llm.stream` — credentials, retry, streaming
- * and metering all stay inside the real adapter's pipeline.
+ * and metering all stay inside the real adapter's pipeline. Incoming model
+ * ids are matched with the leading vendor prefix ignored when the settings
+ * flag is on, and delegation always uses the active provider's raw local id.
  */
 import { LlmAdapter, LlmError, type LlmRuntime } from '@deepseek-ai/dsh-llm'
 import type {
@@ -17,6 +19,7 @@ import {
   displayProvider,
   resolveActive,
   ROUTER_PROVIDER_ID,
+  stripModelIdPrefix,
   type MergedModel,
   type RouterConfigShape,
 } from '../shared/config.js'
@@ -38,19 +41,41 @@ export interface ResolvedRoute {
   provider: string
 }
 
+/**
+ * Find the merged model for an incoming model id. Exact lookup first; when
+ * prefix-ignore is on, a miss falls back to the prefix-stripped id so a raw
+ * `deepseek/deepseek-v4-flash` request matches the merged `deepseek-v4-flash`
+ * (advertised ids are already stripped and hit exactly). Unadvertised ids do
+ * not match.
+ */
+export function mergedFor(facts: RouterFacts, modelId: string): MergedModel | null {
+  const byId = facts.catalog().byId
+  const direct = byId.get(modelId)
+  if (direct !== undefined) return direct
+  if (!facts.config().ignoreModelIdPrefix) return null
+  const stripped = stripModelIdPrefix(modelId)
+  if (stripped === modelId) return null
+  return byId.get(stripped) ?? null
+}
+
 /**
  * Resolve the effective route for one model id: the stored active provider
  * when still present, otherwise the first remaining order entry, otherwise
  * the catalog head. Unadvertised model ids do not route.
  */
 export function routeFor(facts: RouterFacts, modelId: string): ResolvedRoute | null {
-  const merged = facts.catalog().byId.get(modelId)
-  if (merged === undefined) return null
+  const merged = mergedFor(facts, modelId)
+  if (merged === null) return null
   const ids = merged.providers.map(provider => provider.provider)
-  const active = resolveActive(facts.config(), modelId, ids)
+  const active = resolveActive(facts.config(), merged.id, ids)
   return active === null ? null : { provider: active }
 }
 
+/** The raw provider-local id of one provider entry inside a merged model. */
+export function entryRawId(merged: MergedModel, providerId: string): string {
+  return merged.providers.find(provider => provider.provider === providerId)?.id ?? merged.id
+}
+
 export class ModelRouterAdapter extends LlmAdapter {
   constructor(private readonly facts: RouterFacts) {
     super()
@@ -80,20 +105,37 @@ export class ModelRouterAdapter extends LlmAdapter {
 
   async resolveModel(_provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo> {
     const route = routeFor(this.facts, model)
-    if (route === null) {
+    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 resolved = await this.facts.llm().resolveModelInfo(route.provider, model, signal)
-    return { ...resolved, provider: ROUTER_PROVIDER_ID }
+    // 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.
+    const resolved = await this.facts.llm().resolveModelInfo(route.provider, entryRawId(merged, route.provider), signal)
+    const display = displayProvider(merged, route.provider)
+    return {
+      ...resolved,
+      provider: ROUTER_PROVIDER_ID,
+      id: merged.id,
+      name: display?.name ?? resolved.name,
+    }
   }
 
   async *stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
     const route = routeFor(this.facts, options.model)
-    if (route === null) {
+    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')
     }
     // In-process delegation: the inner call resolves the real adapter and
-    // runs its full pipeline (retry, waterfall, replay-state stripping).
-    yield* this.facts.llm().stream({ ...options, provider: route.provider })
+    // runs its full pipeline (retry, waterfall, replay-state stripping). The
+    // model is rewritten to the provider's raw local id — the merged display
+    // id may have had its vendor prefix stripped.
+    yield* this.facts.llm().stream({
+      ...options,
+      provider: route.provider,
+      model: entryRawId(merged, route.provider),
+    })
   }
 }

package/src/server/catalog.ts

@@ -1,9 +1,9 @@
 /**
  * Provider discovery for the router: every registered LLM provider route
- * (minus the router itself) becomes a ProviderInfo, models merge by exact id
- * through the shared core, and per-provider credential status is detected
- * generically through the configurable-provider directory + the credentials
- * seam.
+ * (minus the router itself) becomes a ProviderInfo, models merge through the
+ * shared core (by exact id, or by prefix-stripped id when `ignorePrefix` is
+ * on), and per-provider credential status is detected generically through the
+ * configurable-provider directory + the credentials seam.
  */
 import type { Context } from '@deepseek-ai/cordis'
 import { credentialRef, type CredentialProvider } from '@deepseek-ai/dsh-credentials'
@@ -16,7 +16,7 @@ export interface RouterCatalog {
   providers: ProviderInfo[]
   /** Provider id → human display name (configurable-directory name when known). */
   providerNames: Map<string, string>
-  /** Models merged by exact id across providers. */
+  /** Models merged across providers (exact id, or stripped when flag on). */
   models: MergedModel[]
   /** Model id → merged model. */
   byId: Map<string, MergedModel>
@@ -89,7 +89,7 @@ async function detectCredentialConfigured(
 }
 
 /** Rebuild the live router catalog from the LLM registry. */
-export async function buildCatalog(ctx: Context): Promise<RouterCatalog> {
+export async function buildCatalog(ctx: Context, ignorePrefix = false): Promise<RouterCatalog> {
   const routes = ctx.llm.listProviders().filter(provider => provider.id !== ROUTER_PROVIDER_ID)
   const directory = new Map<string, ConfigurableEntry>(
     ctx.llm.listConfigurableProviders().map(entry => [entry.provider, {
@@ -122,7 +122,7 @@ export async function buildCatalog(ctx: Context): Promise<RouterCatalog> {
     credentialConfigured.set(route.id, await detectCredentialConfigured(ctx, entry))
   }
 
-  const models = mergeModels(providers)
+  const models = mergeModels(providers, { ignorePrefix })
   const byId = new Map(models.map(model => [model.id, model]))
   return { providers, providerNames, models, byId, credentialConfigured }
 }

package/src/server/rpc.ts

@@ -142,6 +142,14 @@ export function registerApiRoutes(ctx: Context, service: ModelRouterService): ()
     return service.state()
   })
 
+  route('set-ignore-model-id-prefix', async (p) => {
+    if (typeof p.value !== 'boolean') {
+      throw new Error('value 必须是布尔值')
+    }
+    await service.setIgnoreModelIdPrefix(p.value)
+    return service.state()
+  })
+
   return () => {
     for (const dispose of disposers) dispose()
   }

package/src/server/service.ts

@@ -10,12 +10,12 @@ import type { AdapterRegistrationHandle } from '@deepseek-ai/dsh-llm'
 import {
   initialConfigFor,
   normalizeConfig,
+  reconcileConfig,
   ROUTER_PROVIDER_ID,
   ROUTER_SETTINGS_NS,
   resolveActive,
   setActive,
   setOrder,
-  syncConfig,
   type RouterConfigShape,
 } from '../shared/config.js'
 import { buildCatalog, type RouterCatalog } from './catalog.js'
@@ -29,17 +29,20 @@ export const RouterConfigSchema: z<RouterConfigShape> = z.object({
     order: z.array(z.string()),
     active: z.string(),
   })),
-  // Older documents predate the toggle; normalizeConfig defaults to true.
+  // Older documents predate the toggles; normalizeConfig defaults both on.
   // Schemastery object keys are input-optional, so absent is valid here.
   showQuickSwitch: z.boolean(),
+  ignoreModelIdPrefix: z.boolean(),
 })
 
-const EMPTY_CONFIG: RouterConfigShape = { models: {}, showQuickSwitch: true }
+const EMPTY_CONFIG: RouterConfigShape = { models: {}, showQuickSwitch: true, ignoreModelIdPrefix: true }
 
 /** The settings-page state view served by the API. */
 export interface ModelRouterState {
   /** Whether the composer quick route-switcher button is enabled. */
   showQuickSwitch: boolean
+  /** Whether model ids are matched with their leading vendor/ prefix ignored. */
+  ignoreModelIdPrefix: boolean
   providers: Array<{ id: string; name: string; credentialConfigured: boolean }>
   models: Array<{
     id: string
@@ -124,7 +127,7 @@ export class ModelRouterService implements RouterFacts {
   /** Rebuild the catalog (in-flight dedupe; failures keep the last good one). */
   refreshCatalog(): Promise<RouterCatalog> {
     if (this.inflight !== null) return this.inflight
-    this.inflight = buildCatalog(this.ctx)
+    this.inflight = buildCatalog(this.ctx, this.config().ignoreModelIdPrefix)
       .then((catalog) => {
         this.cached = catalog
         return catalog
@@ -139,32 +142,19 @@ export class ModelRouterService implements RouterFacts {
     return this.inflight
   }
 
-  /** Refresh, then persist any config drift (new providers/models, vanish). */
+  /** Refresh, then persist any config drift (migration, new/vanished models). */
   async refreshAndReconcile(): Promise<void> {
     const catalog = await this.refreshCatalog()
     if (this.scope === undefined) return
     const current = this.config()
-    const next = { ...current.models }
-    let changed = false
-    for (const model of catalog.models) {
-      const ids = model.providers.map(provider => provider.provider)
-      const result = syncConfig(current, model.id, ids)
-      if (result.changed) changed = true
-      for (const [id, entry] of Object.entries(result.models)) {
-        if (entry === undefined) delete next[id]
-        else next[id] = entry
-      }
-    }
-    // Drop stored entries whose model no longer exists anywhere.
-    for (const id of Object.keys(next)) {
-      if (!catalog.byId.has(id)) {
-        delete next[id]
-        changed = true
-      }
-    }
+    const { models, changed } = reconcileConfig(current, catalog.models)
     if (!changed) return
     try {
-      await this.scope.replace({ models: next, showQuickSwitch: this.config().showQuickSwitch })
+      await this.scope.replace({
+        models,
+        showQuickSwitch: current.showQuickSwitch,
+        ignoreModelIdPrefix: current.ignoreModelIdPrefix,
+      })
     } catch (error) {
       this.ctx.logger.warn(`model-router: reconcile persist failed: ${error instanceof Error ? error.message : String(error)}`)
     }
@@ -187,6 +177,7 @@ export class ModelRouterService implements RouterFacts {
     const creds = catalog.credentialConfigured
     return {
       showQuickSwitch: config.showQuickSwitch,
+      ignoreModelIdPrefix: config.ignoreModelIdPrefix,
       providers: catalog.providers.map(provider => ({
         id: provider.id,
         name: names.get(provider.id) ?? provider.id,
@@ -243,13 +234,42 @@ export class ModelRouterService implements RouterFacts {
     }
     const current = this.config()
     if (current.showQuickSwitch === value) return
-    await this.scope.replace({ models: current.models, showQuickSwitch: value })
+    await this.scope.replace({
+      models: current.models,
+      showQuickSwitch: value,
+      ignoreModelIdPrefix: current.ignoreModelIdPrefix,
+    })
+  }
+
+  /**
+   * Toggle prefix-ignored model matching (global, persisted). Persists the
+   * flag first, then rebuilds the catalog with the new merge rule and
+   * reconciles stored config (migrates prefixed keys to merged ids when
+   * turning on; split models re-initialize when turning off).
+   */
+  async setIgnoreModelIdPrefix(value: boolean): 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.ignoreModelIdPrefix === value) return
+    await this.scope.replace({
+      models: current.models,
+      showQuickSwitch: current.showQuickSwitch,
+      ignoreModelIdPrefix: value,
+    })
+    await this.refreshAndReconcile()
   }
 
   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')
     }
-    await this.scope.replace({ models, showQuickSwitch: this.config().showQuickSwitch })
+    const current = this.config()
+    await this.scope.replace({
+      models,
+      showQuickSwitch: current.showQuickSwitch,
+      ignoreModelIdPrefix: current.ignoreModelIdPrefix,
+    })
   }
 }

package/src/shared/config.ts

@@ -5,7 +5,11 @@
  * (settings page rendering).
  *
  * Decided semantics (grilling session, all recommendations accepted):
- * - Strict merge: models are merged across providers by exact model id only.
+ * - Merge: models are merged across providers by model id — by exact id, or
+ *   (when ignoreModelIdPrefix is on) by id with the first `vendor/` segment
+ *   stripped, so `deepseek/deepseek-v4-flash` and `deepseek-v4-flash` are the
+ *   same model. Display always uses the merged (prefix-free) id; each provider
+ *   entry keeps its own raw local id for delegation.
  * - Per-model provider config: an order[] (future auto-failover preference)
  *   plus an independent active provider (what requests actually route to).
  * - First-seen provider order: for a never-configured model the initial
@@ -14,13 +18,18 @@
  *   the first remaining provider automatically.
  * - New providers for a known model: appended at the end of order; active
  *   untouched.
+ * - Prefix-ignore migration: stored config keyed by a now-stripped raw id
+ *   moves to the merged id (unprefixed entry wins when both exist; order is a
+ *   deduped union). Turning the flag off does not migrate back — the split
+ *   models re-initialize from discovery order.
  */
 
 /** One provider's view of one model. */
 export interface ProviderModelInfo {
   /** Provider id the model belongs to. */
   provider: string
-  /** Provider-local model id (== merged model id, strict merge). */
+  /** Provider-local raw model id, exactly as the provider advertises it
+   *  (may carry a `vendor/` prefix; this is the id delegation must use). */
   id: string
   /** Provider-local display name. */
   name: string
@@ -38,14 +47,16 @@ export interface ProviderInfo {
   models: Array<Omit<ProviderModelInfo, 'provider'>>
 }
 
-/** One merged model across all providers (strict id merge). */
+/** One merged model across all providers. */
 export interface MergedModel {
+  /** Merged display id — the raw id with the leading segment stripped when
+   *  prefix-ignore is on, so it is always shown without a vendor prefix. */
   id: string
-  /** Per-provider entries in provider discovery order. */
+  /** Per-provider entries in provider discovery order (raw local ids). */
   providers: ProviderModelInfo[]
 }
 
-/** Router configuration for one model. */
+/** Router configuration for one model (keyed by merged id). */
 export interface RouterModelConfig {
   /** Provider ids in preference order (future auto-failover). */
   order: string[]
@@ -62,20 +73,63 @@ export interface RouterConfigShape {
    * globally; absent/unknown documents normalize to `true`.
    */
   showQuickSwitch: boolean
+  /**
+   * Whether model ids are matched with their leading `vendor/` segment
+   * ignored (settings → 模型路由 → 匹配时忽略模型 ID 前缀), so
+   * `deepseek/deepseek-v4-flash` and `deepseek-v4-flash` merge into one model
+   * displayed as `deepseek-v4-flash`. Absent/unknown documents normalize to
+   * `true`.
+   */
+  ignoreModelIdPrefix: boolean
 }
 
 export const ROUTER_PROVIDER_ID = 'model-router'
 export const ROUTER_SETTINGS_NS = 'model-router'
 
-/** Merge every provider's models into one entry per exact model id. */
-export function mergeModels(providers: readonly ProviderInfo[]): MergedModel[] {
+/**
+ * Strip the first path segment (`vendor/`) from a model id, case-sensitively.
+ * Inert for ids without a prefix: no slash, an empty first segment, or an
+ * empty remainder all return the input unchanged. `a/b/c` becomes `b/c`.
+ */
+export function stripModelIdPrefix(id: string): string {
+  const slash = id.indexOf('/')
+  if (slash <= 0 || slash === id.length - 1) return id
+  return id.slice(slash + 1)
+}
+
+export interface MergeOptions {
+  /** Group by prefix-stripped id instead of the exact raw id. */
+  ignorePrefix?: boolean
+}
+
+/**
+ * Merge every provider's models into one entry per model id. With
+ * `ignorePrefix` the group key is the prefix-stripped id and the merged id is
+ * that stripped id, while each provider entry keeps its raw local id. When a
+ * single provider advertises both a prefixed and the unprefixed raw id for the
+ * same group (a same-provider collision), the unprefixed raw id wins (it is
+ * the canonical form); otherwise the first-seen raw id wins.
+ */
+export function mergeModels(providers: readonly ProviderInfo[], options: MergeOptions = {}): MergedModel[] {
   const byId = new Map<string, MergedModel>()
   for (const provider of providers) {
+    // Choose one raw id per group key for this provider, preferring the
+    // unprefixed one when both exist.
+    const chosen = new Map<string, string>()
+    for (const model of provider.models) {
+      const key = options.ignorePrefix ? stripModelIdPrefix(model.id) : model.id
+      const prev = chosen.get(key)
+      if (prev === undefined || (prev !== key && model.id === key)) {
+        chosen.set(key, model.id)
+      }
+    }
     for (const model of provider.models) {
-      let merged = byId.get(model.id)
+      const key = options.ignorePrefix ? stripModelIdPrefix(model.id) : model.id
+      if (chosen.get(key) !== model.id) continue
+      let merged = byId.get(key)
       if (merged === undefined) {
-        merged = { id: model.id, providers: [] }
-        byId.set(model.id, merged)
+        merged = { id: key, providers: [] }
+        byId.set(key, merged)
       }
       merged.providers.push({
         provider: provider.id,
@@ -178,6 +232,83 @@ export function syncConfig(
   return { models: next, changed }
 }
 
+function sameModels(a: Record<string, RouterModelConfig>, b: Record<string, RouterModelConfig>): boolean {
+  const aKeys = Object.keys(a)
+  const bKeys = Object.keys(b)
+  if (aKeys.length !== bKeys.length) return false
+  for (const key of aKeys) {
+    const x = a[key]
+    const y = b[key]
+    if (y === undefined || x.active !== y.active || x.order.length !== y.order.length) return false
+    if (!x.order.every((id, i) => id === y.order[i])) return false
+  }
+  return true
+}
+
+/**
+ * Reconcile the stored config document against the live merged catalog.
+ *
+ * Beyond the per-model sync of {@link syncConfig}, this remaps stored entries
+ * to their merged ids: with prefix-ignore on, an entry keyed by a raw id that
+ * now strips to a merged id (e.g. `deepseek/deepseek-v4-flash` →
+ * `deepseek-v4-flash`) migrates to that merged id. When several stored keys
+ * collapse onto one merged id, the entry keyed by the merged id itself wins
+ * for `active`, and `order` becomes the deduped union in exact-key-first
+ * order. Stored keys no longer mapping to any merged model are dropped (this
+ * also covers turning the flag off — split models re-initialize fresh).
+ */
+export function reconcileConfig(
+  config: RouterConfigShape,
+  models: readonly MergedModel[],
+): { models: Record<string, RouterModelConfig>; changed: boolean } {
+  // stored key → merged id it belongs to (exact key wins; prefixed raw keys
+  // map to their stripped merged id only while the flag is on)
+  const keyToMerged = new Map<string, string>()
+  for (const model of models) {
+    keyToMerged.set(model.id, model.id)
+    if (!config.ignoreModelIdPrefix) continue
+    for (const provider of model.providers) {
+      if (stripModelIdPrefix(provider.id) === model.id && !keyToMerged.has(provider.id)) {
+        keyToMerged.set(provider.id, model.id)
+      }
+    }
+  }
+
+  const grouped = new Map<string, Array<{ key: string; entry: RouterModelConfig }>>()
+  for (const [key, entry] of Object.entries(config.models)) {
+    const mergedId = keyToMerged.get(key)
+    if (mergedId === undefined) continue // stale: dropped from the next doc
+    const list = grouped.get(mergedId) ?? []
+    list.push({ key, entry })
+    grouped.set(mergedId, list)
+  }
+
+  const next: Record<string, RouterModelConfig> = {}
+  for (const model of models) {
+    const ids = model.providers.map(provider => provider.provider)
+    const list = grouped.get(model.id)
+    let base: RouterModelConfig | undefined
+    if (list !== undefined && list.length > 0) {
+      const exact = list.find(group => group.key === model.id)
+      const ordered = exact === undefined ? list : [exact, ...list.filter(group => group.key !== model.id)]
+      const order: string[] = []
+      for (const group of ordered) {
+        for (const id of group.entry.order) {
+          if (!order.includes(id)) order.push(id)
+        }
+      }
+      base = { order, active: exact?.entry.active ?? ordered[0].entry.active }
+    }
+    const view: RouterConfigShape = { ...config, models: { ...next } }
+    if (base !== undefined) view.models[model.id] = base
+    const result = syncConfig(view, model.id, ids)
+    const entry = result.models[model.id]
+    if (entry !== undefined) next[model.id] = entry
+  }
+
+  return { models: next, changed: !sameModels(next, config.models) }
+}
+
 /** Switch a model's active provider (no-op when already active). */
 export function setActive(
   config: RouterConfigShape,
@@ -222,11 +353,14 @@ export function setOrder(
 /** Shape-validate an unknown value as a RouterConfigShape (lenient). */
 export function normalizeConfig(value: unknown): RouterConfigShape {
   const models: Record<string, RouterModelConfig> = {}
-  if (typeof value !== 'object' || value === null) return { models, showQuickSwitch: true }
-  const root = value as { models?: unknown; showQuickSwitch?: unknown }
+  if (typeof value !== 'object' || value === null) {
+    return { models, showQuickSwitch: true, ignoreModelIdPrefix: true }
+  }
+  const root = value as { models?: unknown; showQuickSwitch?: unknown; ignoreModelIdPrefix?: unknown }
   const showQuickSwitch = root.showQuickSwitch !== false
+  const ignoreModelIdPrefix = root.ignoreModelIdPrefix !== false
   const raw = root.models
-  if (typeof raw !== 'object' || raw === null) return { models, showQuickSwitch }
+  if (typeof raw !== 'object' || raw === null) return { models, showQuickSwitch, ignoreModelIdPrefix }
   for (const [id, entry] of Object.entries(raw as Record<string, unknown>)) {
     if (typeof entry !== 'object' || entry === null) continue
     const e = entry as { order?: unknown; active?: unknown }
@@ -235,5 +369,5 @@ export function normalizeConfig(value: unknown): RouterConfigShape {
     if (active === '') continue
     models[id] = { order, active }
   }
-  return { models, showQuickSwitch }
+  return { models, showQuickSwitch, ignoreModelIdPrefix }
 }