Merge pull request #68 from grassroadsZ/feature/site-model-disable

feat: 将模型禁用功能从站点移至连接管理

src/server/services/modelService.siteDisable.test.ts

@@ -0,0 +1,177 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { and, eq } from 'drizzle-orm';
+
+type DbModule = typeof import('../db/index.js');
+type ModelServiceModule = typeof import('./modelService.js');
+
+describe('rebuildTokenRoutesFromAvailability with site disabled models', () => {
+    let db: DbModule['db'];
+    let schema: DbModule['schema'];
+    let rebuildTokenRoutesFromAvailability: ModelServiceModule['rebuildTokenRoutesFromAvailability'];
+    let dataDir = '';
+
+    beforeAll(async () => {
+        dataDir = mkdtempSync(join(tmpdir(), 'metapi-site-disabled-models-'));
+        process.env.DATA_DIR = dataDir;
+
+        await import('../db/migrate.js');
+        const dbModule = await import('../db/index.js');
+        const modelService = await import('./modelService.js');
+
+        db = dbModule.db;
+        schema = dbModule.schema;
+        rebuildTokenRoutesFromAvailability = modelService.rebuildTokenRoutesFromAvailability;
+    });
+
+    beforeEach(async () => {
+        await db.delete(schema.routeChannels).run();
+        await db.delete(schema.tokenRoutes).run();
+        await db.delete(schema.tokenModelAvailability).run();
+        await db.delete(schema.modelAvailability).run();
+        await db.delete(schema.siteDisabledModels).run();
+        await db.delete(schema.accountTokens).run();
+        await db.delete(schema.accounts).run();
+        await db.delete(schema.sites).run();
+    });
+
+    afterAll(() => {
+        delete process.env.DATA_DIR;
+    });
+
+    it('does not create route/channel for a model disabled on its site', async () => {
+        const site = await db.insert(schema.sites).values({
+            name: 'site-a',
+            url: 'https://site-a.example.com',
+            platform: 'new-api',
+        }).returning().get();
+
+        const account = await db.insert(schema.accounts).values({
+            siteId: site.id,
+            username: 'user-a',
+            accessToken: '',
+            apiToken: 'sk-test-disabled',
+            status: 'active',
+            extraConfig: JSON.stringify({ credentialMode: 'apikey' }),
+        }).returning().get();
+
+        await db.insert(schema.modelAvailability).values({
+            accountId: account.id,
+            modelName: 'gpt-4o',
+            available: true,
+            latencyMs: 500,
+            checkedAt: '2026-03-12T00:00:00.000Z',
+        }).run();
+
+        // Disable gpt-4o for this site
+        await db.insert(schema.siteDisabledModels).values({
+            siteId: site.id,
+            modelName: 'gpt-4o',
+        }).run();
+
+        const rebuild = await rebuildTokenRoutesFromAvailability();
+
+        expect(rebuild.models).toBe(0);
+
+        const routes = await db.select().from(schema.tokenRoutes)
+            .where(eq(schema.tokenRoutes.modelPattern, 'gpt-4o'))
+            .all();
+        expect(routes).toHaveLength(0);
+    });
+
+    it('only blocks the disabled site, not other sites providing the same model', async () => {
+        const siteA = await db.insert(schema.sites).values({
+            name: 'site-a',
+            url: 'https://site-a.example.com',
+            platform: 'new-api',
+        }).returning().get();
+
+        const siteB = await db.insert(schema.sites).values({
+            name: 'site-b',
+            url: 'https://site-b.example.com',
+            platform: 'new-api',
+        }).returning().get();
+
+        const accountA = await db.insert(schema.accounts).values({
+            siteId: siteA.id,
+            username: 'user-a',
+            accessToken: '',
+            apiToken: 'sk-site-a',
+            status: 'active',
+            extraConfig: JSON.stringify({ credentialMode: 'apikey' }),
+        }).returning().get();
+
+        const accountB = await db.insert(schema.accounts).values({
+            siteId: siteB.id,
+            username: 'user-b',
+            accessToken: '',
+            apiToken: 'sk-site-b',
+            status: 'active',
+            extraConfig: JSON.stringify({ credentialMode: 'apikey' }),
+        }).returning().get();
+
+        // Both sites have the same model
+        await db.insert(schema.modelAvailability).values([
+            { accountId: accountA.id, modelName: 'claude-sonnet-4-5-20250929', available: true, latencyMs: 300 },
+            { accountId: accountB.id, modelName: 'claude-sonnet-4-5-20250929', available: true, latencyMs: 400 },
+        ]).run();
+
+        // Disable the model only on site A
+        await db.insert(schema.siteDisabledModels).values({
+            siteId: siteA.id,
+            modelName: 'claude-sonnet-4-5-20250929',
+        }).run();
+
+        const rebuild = await rebuildTokenRoutesFromAvailability();
+
+        expect(rebuild.models).toBe(1);
+
+        const route = await db.select().from(schema.tokenRoutes)
+            .where(eq(schema.tokenRoutes.modelPattern, 'claude-sonnet-4-5-20250929'))
+            .get();
+        expect(route).toBeDefined();
+
+        const channels = await db.select().from(schema.routeChannels)
+            .where(eq(schema.routeChannels.routeId, route!.id))
+            .all();
+
+        // Only site B's channel should exist
+        expect(channels).toHaveLength(1);
+        expect(channels[0]?.accountId).toBe(accountB.id);
+    });
+
+    it('allows model when no disabled models are configured', async () => {
+        const site = await db.insert(schema.sites).values({
+            name: 'normal-site',
+            url: 'https://normal.example.com',
+            platform: 'new-api',
+        }).returning().get();
+
+        const account = await db.insert(schema.accounts).values({
+            siteId: site.id,
+            username: 'normal-user',
+            accessToken: '',
+            apiToken: 'sk-normal',
+            status: 'active',
+            extraConfig: JSON.stringify({ credentialMode: 'apikey' }),
+        }).returning().get();
+
+        await db.insert(schema.modelAvailability).values({
+            accountId: account.id,
+            modelName: 'gpt-5',
+            available: true,
+            latencyMs: 200,
+        }).run();
+
+        const rebuild = await rebuildTokenRoutesFromAvailability();
+
+        expect(rebuild.models).toBe(1);
+
+        const route = await db.select().from(schema.tokenRoutes)
+            .where(eq(schema.tokenRoutes.modelPattern, 'gpt-5'))
+            .get();
+        expect(route).toBeDefined();
+    });
+});

src/server/services/modelService.ts

@@ -6,7 +6,7 @@ import { getCredentialModeFromExtraConfig, resolvePlatformUserId } from './accou
 import { invalidateTokenRouterCache } from './tokenRouter.js';
 import { setAccountRuntimeHealth } from './accountHealthService.js';
 import { clearAllRouteDecisionSnapshots } from './routeDecisionSnapshotStore.js';
-
+
 const API_TOKEN_DISCOVERY_TIMEOUT_MS = 8_000;
 const MODEL_DISCOVERY_TIMEOUT_MS = 12_000;
 const MODEL_REFRESH_BATCH_SIZE = 3;
@@ -38,38 +38,38 @@ function isApiKeyConnection(account: typeof schema.accounts.$inferSelect): boole
   if (explicit && explicit !== 'auto') return explicit === 'apikey';
   return !(account.accessToken || '').trim();
 }
-
-function normalizeModels(models: string[]): string[] {
-  return Array.from(new Set(models.filter((model) => typeof model === 'string' && model.trim().length > 0)));
-}
-
-function isExactModelPattern(modelPattern: string): boolean {
-  const normalized = modelPattern.trim();
-  if (!normalized) return false;
-  if (normalized.toLowerCase().startsWith('re:')) return false;
-  return !/[\*\?\[]/.test(normalized);
-}
-
-async function withTimeout<T>(fn: () => Promise<T>, timeoutMs: number, timeoutMessage: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  try {
-    return await Promise.race([
-      fn(),
-      new Promise<T>((_, reject) => {
-        timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
-      }),
-    ]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-
-export async function refreshModelsForAccount(accountId: number) {
-  const row = await db.select().from(schema.accounts)
-    .innerJoin(schema.sites, eq(schema.accounts.siteId, schema.sites.id))
-    .where(eq(schema.accounts.id, accountId))
-    .get();
-
+
+function normalizeModels(models: string[]): string[] {
+  return Array.from(new Set(models.filter((model) => typeof model === 'string' && model.trim().length > 0)));
+}
+
+function isExactModelPattern(modelPattern: string): boolean {
+  const normalized = modelPattern.trim();
+  if (!normalized) return false;
+  if (normalized.toLowerCase().startsWith('re:')) return false;
+  return !/[\*\?\[]/.test(normalized);
+}
+
+async function withTimeout<T>(fn: () => Promise<T>, timeoutMs: number, timeoutMessage: string): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  try {
+    return await Promise.race([
+      fn(),
+      new Promise<T>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+export async function refreshModelsForAccount(accountId: number) {
+  const row = await db.select().from(schema.accounts)
+    .innerJoin(schema.sites, eq(schema.accounts.siteId, schema.sites.id))
+    .where(eq(schema.accounts.id, accountId))
+    .get();
+
   if (!row) {
     return {
       accountId,
@@ -82,26 +82,26 @@ export async function refreshModelsForAccount(accountId: number) {
       reason: 'account_not_found',
     };
   }
-
-  const account = row.accounts;
-  const site = row.sites;
-  const adapter = getAdapter(site.platform);
-
-  const accountTokens = await db.select()
-    .from(schema.accountTokens)
-    .where(eq(schema.accountTokens.accountId, accountId))
-    .all();
-
-  await db.delete(schema.modelAvailability)
-    .where(eq(schema.modelAvailability.accountId, accountId))
-    .run();
-
-  for (const token of accountTokens) {
-    await db.delete(schema.tokenModelAvailability)
-      .where(eq(schema.tokenModelAvailability.tokenId, token.id))
-      .run();
-  }
-
+
+  const account = row.accounts;
+  const site = row.sites;
+  const adapter = getAdapter(site.platform);
+
+  const accountTokens = await db.select()
+    .from(schema.accountTokens)
+    .where(eq(schema.accountTokens.accountId, accountId))
+    .all();
+
+  await db.delete(schema.modelAvailability)
+    .where(eq(schema.modelAvailability.accountId, accountId))
+    .run();
+
+  for (const token of accountTokens) {
+    await db.delete(schema.tokenModelAvailability)
+      .where(eq(schema.tokenModelAvailability.tokenId, token.id))
+      .run();
+  }
+
   if (isSiteDisabled(site.status)) {
     return {
       accountId,
@@ -127,44 +127,44 @@ export async function refreshModelsForAccount(accountId: number) {
       reason: 'adapter_or_status',
     };
   }
-
-  const platformUserId = resolvePlatformUserId(account.extraConfig, account.username);
-  let discoveredApiToken: string | null = null;
-
-  if (!account.apiToken && account.accessToken) {
-    try {
-      discoveredApiToken = await withTimeout(
-        () => adapter.getApiToken(site.url, account.accessToken, platformUserId),
-        API_TOKEN_DISCOVERY_TIMEOUT_MS,
-        `api token discovery timeout (${Math.round(API_TOKEN_DISCOVERY_TIMEOUT_MS / 1000)}s)`,
-      );
-      if (discoveredApiToken) {
-        ensureDefaultTokenForAccount(account.id, discoveredApiToken, { name: 'default', source: 'sync' });
-        await db.update(schema.accounts).set({
-          apiToken: discoveredApiToken,
-          updatedAt: new Date().toISOString(),
-        }).where(eq(schema.accounts.id, account.id)).run();
-      }
-    } catch {}
-  }
-
-  let enabledTokens = await db.select()
-    .from(schema.accountTokens)
-    .where(and(eq(schema.accountTokens.accountId, account.id), eq(schema.accountTokens.enabled, true)))
-    .all();
-
-  // Last fallback: if still no managed token but account has a legacy apiToken, mirror it into token table.
+
+  const platformUserId = resolvePlatformUserId(account.extraConfig, account.username);
+  let discoveredApiToken: string | null = null;
+
+  if (!account.apiToken && account.accessToken) {
+    try {
+      discoveredApiToken = await withTimeout(
+        () => adapter.getApiToken(site.url, account.accessToken, platformUserId),
+        API_TOKEN_DISCOVERY_TIMEOUT_MS,
+        `api token discovery timeout (${Math.round(API_TOKEN_DISCOVERY_TIMEOUT_MS / 1000)}s)`,
+      );
+      if (discoveredApiToken) {
+        ensureDefaultTokenForAccount(account.id, discoveredApiToken, { name: 'default', source: 'sync' });
+        await db.update(schema.accounts).set({
+          apiToken: discoveredApiToken,
+          updatedAt: new Date().toISOString(),
+        }).where(eq(schema.accounts.id, account.id)).run();
+      }
+    } catch { }
+  }
+
+  let enabledTokens = await db.select()
+    .from(schema.accountTokens)
+    .where(and(eq(schema.accountTokens.accountId, account.id), eq(schema.accountTokens.enabled, true)))
+    .all();
+
+  // Last fallback: if still no managed token but account has a legacy apiToken, mirror it into token table.
   if (!isApiKeyConnection(account) && enabledTokens.length === 0) {
     const fallback = discoveredApiToken || account.apiToken || null;
     if (fallback) {
       ensureDefaultTokenForAccount(account.id, fallback, { name: 'default', source: 'legacy' });
-      enabledTokens = await db.select()
-        .from(schema.accountTokens)
-        .where(and(eq(schema.accountTokens.accountId, account.id), eq(schema.accountTokens.enabled, true)))
-        .all();
-    }
-  }
-
+      enabledTokens = await db.select()
+        .from(schema.accountTokens)
+        .where(and(eq(schema.accountTokens.accountId, account.id), eq(schema.accountTokens.enabled, true)))
+        .all();
+    }
+  }
+
   const accountModels = new Set<string>();
   const modelLatency = new Map<string, number | null>();
   let scannedTokenCount = 0;
@@ -175,27 +175,27 @@ export async function refreshModelsForAccount(accountId: number) {
     const message = (err as { message?: string })?.message || String(err || '');
     if (message) failureMessages.push(message);
   };
-
-  const mergeDiscoveredModels = (models: string[], latencyMs: number | null) => {
-    for (const modelName of models) {
-      accountModels.add(modelName);
-      const prev = modelLatency.get(modelName);
-      if (prev === undefined || prev === null) {
-        modelLatency.set(modelName, latencyMs);
-        continue;
-      }
-      if (latencyMs === null) continue;
-      if (latencyMs < prev) modelLatency.set(modelName, latencyMs);
-    }
-  };
-
-  const discoverModelsWithCredential = async (credentialRaw: string | null | undefined) => {
-    const credential = (credentialRaw || '').trim();
-    if (!credential) return;
-    if (attemptedCredentials.has(credential)) return;
-    attemptedCredentials.add(credential);
-
-    const startedAt = Date.now();
+
+  const mergeDiscoveredModels = (models: string[], latencyMs: number | null) => {
+    for (const modelName of models) {
+      accountModels.add(modelName);
+      const prev = modelLatency.get(modelName);
+      if (prev === undefined || prev === null) {
+        modelLatency.set(modelName, latencyMs);
+        continue;
+      }
+      if (latencyMs === null) continue;
+      if (latencyMs < prev) modelLatency.set(modelName, latencyMs);
+    }
+  };
+
+  const discoverModelsWithCredential = async (credentialRaw: string | null | undefined) => {
+    const credential = (credentialRaw || '').trim();
+    if (!credential) return;
+    if (attemptedCredentials.has(credential)) return;
+    attemptedCredentials.add(credential);
+
+    const startedAt = Date.now();
     let models: string[] = [];
     try {
       models = normalizeModels(
@@ -210,18 +210,18 @@ export async function refreshModelsForAccount(accountId: number) {
       models = [];
     }
     if (models.length === 0) return;
-    discoveredByCredential = true;
-    const latencyMs = Date.now() - startedAt;
-    mergeDiscoveredModels(models, latencyMs);
-  };
-
-  // Prefer account-level credential discovery so model availability does not rely on managed tokens.
-  await discoverModelsWithCredential(account.apiToken);
-  await discoverModelsWithCredential(discoveredApiToken);
-  await discoverModelsWithCredential(account.accessToken);
-
-  for (const token of enabledTokens) {
-    const startedAt = Date.now();
+    discoveredByCredential = true;
+    const latencyMs = Date.now() - startedAt;
+    mergeDiscoveredModels(models, latencyMs);
+  };
+
+  // Prefer account-level credential discovery so model availability does not rely on managed tokens.
+  await discoverModelsWithCredential(account.apiToken);
+  await discoverModelsWithCredential(discoveredApiToken);
+  await discoverModelsWithCredential(account.accessToken);
+
+  for (const token of enabledTokens) {
+    const startedAt = Date.now();
     let models: string[] = [];
 
     try {
@@ -236,26 +236,26 @@ export async function refreshModelsForAccount(accountId: number) {
       recordFailure(err);
       models = [];
     }
-
-    if (models.length === 0) continue;
-
-    const latencyMs = Date.now() - startedAt;
-    const checkedAt = new Date().toISOString();
-
-    await db.insert(schema.tokenModelAvailability).values(
-      models.map((modelName) => ({
-        tokenId: token.id,
-        modelName,
-        available: true,
-        latencyMs,
-        checkedAt,
-      })),
-    ).run();
-
-    scannedTokenCount++;
-    mergeDiscoveredModels(models, latencyMs);
-  }
-
+
+    if (models.length === 0) continue;
+
+    const latencyMs = Date.now() - startedAt;
+    const checkedAt = new Date().toISOString();
+
+    await db.insert(schema.tokenModelAvailability).values(
+      models.map((modelName) => ({
+        tokenId: token.id,
+        modelName,
+        available: true,
+        latencyMs,
+        checkedAt,
+      })),
+    ).run();
+
+    scannedTokenCount++;
+    mergeDiscoveredModels(models, latencyMs);
+  }
+
   if (accountModels.size === 0) {
     const firstMessage = failureMessages[0] || '';
     const errorCode = firstMessage ? classifyModelDiscoveryError(firstMessage) : 'empty_models';
@@ -312,33 +312,33 @@ export async function refreshModelsForAccount(accountId: number) {
     discoveredApiToken: !!discoveredApiToken,
   };
 }
-
-async function refreshModelsForAllActiveAccounts() {
-  const accounts = await db.select({ id: schema.accounts.id }).from(schema.accounts)
-    .where(eq(schema.accounts.status, 'active'))
-    .all();
-
+
+async function refreshModelsForAllActiveAccounts() {
+  const accounts = await db.select({ id: schema.accounts.id }).from(schema.accounts)
+    .where(eq(schema.accounts.status, 'active'))
+    .all();
+
   const results: any[] = [];
-  for (let offset = 0; offset < accounts.length; offset += MODEL_REFRESH_BATCH_SIZE) {
-    const batch = accounts.slice(offset, offset + MODEL_REFRESH_BATCH_SIZE);
-    const batchResults = await Promise.all(batch.map(async (account) => refreshModelsForAccount(account.id)));
-    results.push(...batchResults);
-  }
-  return results;
-}
-
+  for (let offset = 0; offset < accounts.length; offset += MODEL_REFRESH_BATCH_SIZE) {
+    const batch = accounts.slice(offset, offset + MODEL_REFRESH_BATCH_SIZE);
+    const batchResults = await Promise.all(batch.map(async (account) => refreshModelsForAccount(account.id)));
+    results.push(...batchResults);
+  }
+  return results;
+}
+
 export async function rebuildTokenRoutesFromAvailability() {
   const tokenRows = await db.select().from(schema.tokenModelAvailability)
-    .innerJoin(schema.accountTokens, eq(schema.tokenModelAvailability.tokenId, schema.accountTokens.id))
-    .innerJoin(schema.accounts, eq(schema.accountTokens.accountId, schema.accounts.id))
-    .innerJoin(schema.sites, eq(schema.accounts.siteId, schema.sites.id))
-    .where(
-      and(
-        eq(schema.tokenModelAvailability.available, true),
-        eq(schema.accountTokens.enabled, true),
-        eq(schema.accounts.status, 'active'),
-        eq(schema.sites.status, 'active'),
-      ),
+    .innerJoin(schema.accountTokens, eq(schema.tokenModelAvailability.tokenId, schema.accountTokens.id))
+    .innerJoin(schema.accounts, eq(schema.accountTokens.accountId, schema.accounts.id))
+    .innerJoin(schema.sites, eq(schema.accounts.siteId, schema.sites.id))
+    .where(
+      and(
+        eq(schema.tokenModelAvailability.available, true),
+        eq(schema.accountTokens.enabled, true),
+        eq(schema.accounts.status, 'active'),
+        eq(schema.sites.status, 'active'),
+      ),
     )
     .all();
 
@@ -354,29 +354,43 @@ export async function rebuildTokenRoutesFromAvailability() {
     )
     .all();
 
+  // Load site-level disabled models
+  const disabledModelRows = await db.select().from(schema.siteDisabledModels).all();
+  const disabledModelsBySite = new Map<number, Set<string>>();
+  for (const row of disabledModelRows) {
+    if (!disabledModelsBySite.has(row.siteId)) disabledModelsBySite.set(row.siteId, new Set());
+    disabledModelsBySite.get(row.siteId)!.add(row.modelName);
+  }
+
+  function isModelDisabledForSite(siteId: number, modelName: string): boolean {
+    const disabled = disabledModelsBySite.get(siteId);
+    return !!disabled && disabled.has(modelName);
+  }
+
   const modelCandidates = new Map<string, Map<string, { accountId: number; tokenId: number | null }>>();
-  const addModelCandidate = (modelNameRaw: string | null | undefined, accountId: number, tokenId: number | null) => {
+  const addModelCandidate = (modelNameRaw: string | null | undefined, accountId: number, tokenId: number | null, siteId: number) => {
     const modelName = (modelNameRaw || '').trim();
     if (!modelName) return;
+    if (isModelDisabledForSite(siteId, modelName)) return;
     if (!modelCandidates.has(modelName)) modelCandidates.set(modelName, new Map());
     const candidateKey = `${accountId}:${tokenId ?? 'account'}`;
     modelCandidates.get(modelName)!.set(candidateKey, { accountId, tokenId });
   };
 
   for (const row of tokenRows) {
-    addModelCandidate(row.token_model_availability.modelName, row.accounts.id, row.account_tokens.id);
+    addModelCandidate(row.token_model_availability.modelName, row.accounts.id, row.account_tokens.id, row.accounts.siteId);
   }
 
   for (const row of accountRows) {
     if (!isApiKeyConnection(row.accounts)) continue;
     if (!(row.accounts.apiToken || '').trim()) continue;
-    addModelCandidate(row.model_availability.modelName, row.accounts.id, null);
+    addModelCandidate(row.model_availability.modelName, row.accounts.id, null, row.accounts.siteId);
   }
 
   const routes = await db.select().from(schema.tokenRoutes).all();
   const channels = await db.select().from(schema.routeChannels).all();
-
-  let createdRoutes = 0;
+
+  let createdRoutes = 0;
   let createdChannels = 0;
   let removedChannels = 0;
   let removedRoutes = 0;
@@ -439,12 +453,12 @@ export async function rebuildTokenRoutesFromAvailability() {
             .where(eq(schema.routeChannels.id, channel.id))
             .run();
           continue;
-        }
-      }
-
-      if (!channel.manualOverride) {
-        await db.delete(schema.routeChannels).where(eq(schema.routeChannels.id, channel.id)).run();
-        removedChannels++;
+        }
+      }
+
+      if (!channel.manualOverride) {
+        await db.delete(schema.routeChannels).where(eq(schema.routeChannels.id, channel.id)).run();
+        removedChannels++;
       }
     }
   }
@@ -454,16 +468,16 @@ export async function rebuildTokenRoutesFromAvailability() {
     const modelPattern = (route.modelPattern || '').trim();
     if (!modelPattern || !isExactModelPattern(modelPattern) || latestModelNames.has(modelPattern)) {
       continue;
-    }
-
-    const routeChannelCount = channels.filter((channel) => channel.routeId === route.id).length;
-    if (routeChannelCount > 0) {
-      removedChannels += routeChannelCount;
-    }
-
-    const deleted = (await db.delete(schema.tokenRoutes).where(eq(schema.tokenRoutes.id, route.id)).run()).changes;
-    if (deleted > 0) {
-      removedRoutes += deleted;
+    }
+
+    const routeChannelCount = channels.filter((channel) => channel.routeId === route.id).length;
+    if (routeChannelCount > 0) {
+      removedChannels += routeChannelCount;
+    }
+
+    const deleted = (await db.delete(schema.tokenRoutes).where(eq(schema.tokenRoutes.id, route.id)).run()).changes;
+    if (deleted > 0) {
+      removedRoutes += deleted;
     }
   }
 
@@ -472,7 +486,7 @@ export async function rebuildTokenRoutesFromAvailability() {
   }
 
   invalidateTokenRouterCache();
-
+
   return {
     models: modelCandidates.size,
     createdRoutes,
@@ -480,8 +494,8 @@ export async function rebuildTokenRoutesFromAvailability() {
     removedChannels,
     removedRoutes,
   };
-}
-
+}
+
 export async function refreshModelsAndRebuildRoutes() {
   const refresh = await refreshModelsForAllActiveAccounts();
   const rebuild = await rebuildTokenRoutesFromAvailability();