feat: Add manual model availability management, including database schema updates, new API routes, and UI components.

src/server/db/generated/mysql.bootstrap.sql

@@ -4,7 +4,7 @@ CREATE TABLE IF NOT EXISTS `account_tokens` (`id` INT AUTO_INCREMENT NOT NULL PR
 CREATE TABLE IF NOT EXISTS `checkin_logs` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `account_id` INT NOT NULL, `status` TEXT NOT NULL, `message` TEXT, `reward` TEXT, `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS `downstream_api_keys` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `name` TEXT NOT NULL, `key` TEXT NOT NULL, `description` TEXT, `enabled` BOOLEAN DEFAULT true, `expires_at` DATETIME, `max_cost` DOUBLE, `used_cost` DOUBLE DEFAULT 0, `max_requests` INT, `used_requests` INT DEFAULT 0, `supported_models` JSON, `allowed_route_ids` JSON, `site_weight_multipliers` JSON, `last_used_at` DATETIME, `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP, `updated_at` DATETIME DEFAULT CURRENT_TIMESTAMP);
 CREATE TABLE IF NOT EXISTS `events` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `type` TEXT NOT NULL, `title` TEXT NOT NULL, `message` TEXT, `level` VARCHAR(191) NOT NULL DEFAULT 'info', `read` BOOLEAN DEFAULT false, `related_id` INT, `related_type` TEXT, `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP);
-CREATE TABLE IF NOT EXISTS `model_availability` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `account_id` INT NOT NULL, `model_name` TEXT NOT NULL, `available` BOOLEAN, `latency_ms` INT, `checked_at` DATETIME DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS `model_availability` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `account_id` INT NOT NULL, `model_name` TEXT NOT NULL, `available` BOOLEAN, `latency_ms` INT, `checked_at` DATETIME DEFAULT CURRENT_TIMESTAMP, `is_manual` BOOLEAN DEFAULT false, FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS `proxy_files` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `public_id` TEXT NOT NULL, `owner_type` TEXT NOT NULL, `owner_id` TEXT NOT NULL, `filename` TEXT NOT NULL, `mime_type` TEXT NOT NULL, `purpose` TEXT, `byte_size` INT NOT NULL, `sha256` TEXT NOT NULL, `content_base64` TEXT NOT NULL, `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP, `updated_at` DATETIME DEFAULT CURRENT_TIMESTAMP, `deleted_at` DATETIME);
 CREATE TABLE IF NOT EXISTS `proxy_logs` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `route_id` INT, `channel_id` INT, `account_id` INT, `model_requested` TEXT, `model_actual` TEXT, `status` TEXT, `http_status` INT, `latency_ms` INT, `prompt_tokens` INT, `completion_tokens` INT, `total_tokens` INT, `estimated_cost` DOUBLE, `error_message` TEXT, `retry_count` INT DEFAULT 0, `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP, `billing_details` JSON);
 CREATE TABLE IF NOT EXISTS `proxy_video_tasks` (`id` INT AUTO_INCREMENT NOT NULL PRIMARY KEY, `public_id` TEXT NOT NULL, `upstream_video_id` TEXT NOT NULL, `site_url` TEXT NOT NULL, `token_value` TEXT NOT NULL, `requested_model` TEXT, `actual_model` TEXT, `channel_id` INT, `account_id` INT, `status_snapshot` JSON, `upstream_response_meta` JSON, `last_upstream_status` INT, `last_polled_at` DATETIME, `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP, `updated_at` DATETIME DEFAULT CURRENT_TIMESTAMP);

src/server/db/generated/mysql.upgrade.sql

@@ -1 +1 @@
--- no schema changes detected for mysql
+ALTER TABLE `model_availability` ADD COLUMN `is_manual` BOOLEAN DEFAULT false;

src/server/db/generated/postgres.bootstrap.sql

@@ -4,7 +4,7 @@ CREATE TABLE IF NOT EXISTS "account_tokens" ("id" INTEGER GENERATED BY DEFAULT A
 CREATE TABLE IF NOT EXISTS "checkin_logs" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "account_id" INTEGER NOT NULL, "status" TEXT NOT NULL, "message" TEXT, "reward" TEXT, "created_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY ("account_id") REFERENCES "accounts"("id") ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS "downstream_api_keys" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "name" TEXT NOT NULL, "key" TEXT NOT NULL, "description" TEXT, "enabled" BOOLEAN DEFAULT true, "expires_at" TIMESTAMP, "max_cost" DOUBLE PRECISION, "used_cost" DOUBLE PRECISION DEFAULT 0, "max_requests" INTEGER, "used_requests" INTEGER DEFAULT 0, "supported_models" JSONB, "allowed_route_ids" JSONB, "site_weight_multipliers" JSONB, "last_used_at" TIMESTAMP, "created_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "updated_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP);
 CREATE TABLE IF NOT EXISTS "events" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "type" TEXT NOT NULL, "title" TEXT NOT NULL, "message" TEXT, "level" TEXT NOT NULL DEFAULT 'info', "read" BOOLEAN DEFAULT false, "related_id" INTEGER, "related_type" TEXT, "created_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP);
-CREATE TABLE IF NOT EXISTS "model_availability" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "account_id" INTEGER NOT NULL, "model_name" TEXT NOT NULL, "available" BOOLEAN, "latency_ms" INTEGER, "checked_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY ("account_id") REFERENCES "accounts"("id") ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS "model_availability" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "account_id" INTEGER NOT NULL, "model_name" TEXT NOT NULL, "available" BOOLEAN, "latency_ms" INTEGER, "checked_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "is_manual" BOOLEAN DEFAULT false, FOREIGN KEY ("account_id") REFERENCES "accounts"("id") ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS "proxy_files" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "public_id" TEXT NOT NULL, "owner_type" TEXT NOT NULL, "owner_id" TEXT NOT NULL, "filename" TEXT NOT NULL, "mime_type" TEXT NOT NULL, "purpose" TEXT, "byte_size" INTEGER NOT NULL, "sha256" TEXT NOT NULL, "content_base64" TEXT NOT NULL, "created_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "updated_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "deleted_at" TIMESTAMP);
 CREATE TABLE IF NOT EXISTS "proxy_logs" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "route_id" INTEGER, "channel_id" INTEGER, "account_id" INTEGER, "model_requested" TEXT, "model_actual" TEXT, "status" TEXT, "http_status" INTEGER, "latency_ms" INTEGER, "prompt_tokens" INTEGER, "completion_tokens" INTEGER, "total_tokens" INTEGER, "estimated_cost" DOUBLE PRECISION, "error_message" TEXT, "retry_count" INTEGER DEFAULT 0, "created_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "billing_details" JSONB);
 CREATE TABLE IF NOT EXISTS "proxy_video_tasks" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "public_id" TEXT NOT NULL, "upstream_video_id" TEXT NOT NULL, "site_url" TEXT NOT NULL, "token_value" TEXT NOT NULL, "requested_model" TEXT, "actual_model" TEXT, "channel_id" INTEGER, "account_id" INTEGER, "status_snapshot" JSONB, "upstream_response_meta" JSONB, "last_upstream_status" INTEGER, "last_polled_at" TIMESTAMP, "created_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "updated_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP);

src/server/db/generated/postgres.upgrade.sql

@@ -1 +1 @@
--- no schema changes detected for postgres
+ALTER TABLE "model_availability" ADD COLUMN "is_manual" BOOLEAN DEFAULT false;

src/server/db/generated/schemaContract.json

@@ -417,6 +417,12 @@
           "notNull": false,
           "defaultValue": "datetime('now')",
           "primaryKey": false
+        },
+        "is_manual": {
+          "logicalType": "boolean",
+          "notNull": false,
+          "defaultValue": "false",
+          "primaryKey": false
         }
       }
     },

src/server/db/migrate.test.ts

@@ -232,7 +232,7 @@ describe('sqlite migrate bootstrap', () => {
       JSON.stringify({
         entries: [
           {
-            tag: '0008_sqlite_schema_backfill',
+            tag: '0009_model_availability_is_manual',
             when: 1772600000000,
           },
         ],
@@ -240,7 +240,7 @@ describe('sqlite migrate bootstrap', () => {
     );
 
     writeFileSync(
-      join(tempMigrationsDir, '0008_sqlite_schema_backfill.sql'),
+      join(tempMigrationsDir, '0009_model_availability_is_manual.sql'),
       [
         'CREATE TABLE IF NOT EXISTS `downstream_api_keys` (`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL);',
         'ALTER TABLE `account_tokens` ADD `token_group` text;',
@@ -282,6 +282,7 @@ describe('sqlite migrate bootstrap', () => {
       '0006_site_disabled_models',
       '0007_account_token_group',
       '0008_sqlite_schema_backfill',
+      '0009_model_availability_is_manual',
     ]);
     const appliedEntries = journalEntries.filter((entry) => !missingTags.has(entry.tag));
 

src/server/db/migrate.ts

@@ -34,7 +34,7 @@ type RecoveryMigration = RecoveryMigrationRecord & {
   statements: string[];
 };
 
-const VERIFIED_BOOTSTRAP_TAG = '0007_account_token_group';
+const VERIFIED_BOOTSTRAP_TAG = '0009_model_availability_is_manual';
 const VERIFIED_SCHEMA_MARKERS: SchemaMarker[] = [
   { table: 'sites' },
   { table: 'settings' },
@@ -55,6 +55,8 @@ const VERIFIED_SCHEMA_MARKERS: SchemaMarker[] = [
   { table: 'site_disabled_models' },
   // 0007: token_group column on account_tokens
   { table: 'account_tokens', column: 'token_group' },
+  // 0009: is_manual column on model_availability
+  { table: 'model_availability', column: 'is_manual' },
 ];
 
 

src/server/db/schema.ts

@@ -92,6 +92,7 @@ export const modelAvailability = sqliteTable('model_availability', {
   accountId: integer('account_id').notNull().references(() => accounts.id, { onDelete: 'cascade' }),
   modelName: text('model_name').notNull(),
   available: integer('available', { mode: 'boolean' }),
+  isManual: integer('is_manual', { mode: 'boolean' }).default(false),
   latencyMs: integer('latency_ms'),
   checkedAt: text('checked_at').default(sql`(datetime('now'))`),
 }, (table) => ({

src/server/routes/api/accounts.manual-models.test.ts

@@ -0,0 +1,133 @@
+import Fastify, { type FastifyInstance } from 'fastify';
+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 { eq } from 'drizzle-orm';
+
+type DbModule = typeof import('../../db/index.js');
+
+describe('accounts manual models endpoint', () => {
+  let app: FastifyInstance;
+  let db: DbModule['db'];
+  let schema: DbModule['schema'];
+  let dataDir = '';
+
+  beforeAll(async () => {
+    dataDir = mkdtempSync(join(tmpdir(), 'metapi-accounts-manual-models-'));
+    process.env.DATA_DIR = dataDir;
+
+    await import('../../db/migrate.js');
+    const dbModule = await import('../../db/index.js');
+    const routesModule = await import('./accounts.js');
+    db = dbModule.db;
+    schema = dbModule.schema;
+
+    app = Fastify();
+    await app.register(routesModule.accountsRoutes);
+  });
+
+  beforeEach(async () => {
+    await db.delete(schema.proxyLogs).run();
+    await db.delete(schema.checkinLogs).run();
+    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.accountTokens).run();
+    await db.delete(schema.accounts).run();
+    await db.delete(schema.sites).run();
+  });
+
+  afterAll(async () => {
+    await app.close();
+    delete process.env.DATA_DIR;
+  });
+
+  it('adds manual models and sets isManual to true', async () => {
+    const site = await db.insert(schema.sites).values({
+      name: 'Test Site',
+      url: 'https://test.example.com',
+      platform: 'new-api',
+    }).returning().get();
+
+    const account = await db.insert(schema.accounts).values({
+      siteId: site.id,
+      accessToken: 'test-token',
+    }).returning().get();
+
+    const response = await app.inject({
+      method: 'POST',
+      url: `/api/accounts/${account.id}/models/manual`,
+      payload: {
+        models: ['gpt-4-manual', 'claude-3-manual'],
+      },
+    });
+
+    expect(response.statusCode).toBe(200);
+    const body = response.json();
+    expect(body.success).toBe(true);
+
+    const models = await db.select().from(schema.modelAvailability).where(
+      eq(schema.modelAvailability.accountId, account.id)
+    ).all();
+    
+    expect(models).toHaveLength(2);
+    expect(models.map(m => m.modelName).sort()).toEqual(['claude-3-manual', 'gpt-4-manual']);
+    expect(models[0]?.isManual).toBe(true);
+    expect(models[1]?.isManual).toBe(true);
+  });
+
+  it('updates existing synced models to manual if provided', async () => {
+    const site = await db.insert(schema.sites).values({
+      name: 'Test Site',
+      url: 'https://test.example.com',
+      platform: 'new-api',
+    }).returning().get();
+
+    const account = await db.insert(schema.accounts).values({
+      siteId: site.id,
+      accessToken: 'test-token',
+    }).returning().get();
+
+    // Already-synced model that is NOT manual
+    await db.insert(schema.modelAvailability).values({
+      accountId: account.id,
+      modelName: 'gpt-existing',
+      available: true,
+    });
+
+    const response = await app.inject({
+      method: 'POST',
+      url: `/api/accounts/${account.id}/models/manual`,
+      payload: {
+        models: ['gpt-existing', 'gpt-new'],
+      },
+    });
+
+    expect(response.statusCode).toBe(200);
+
+    const models = await db.select().from(schema.modelAvailability)
+      .where(eq(schema.modelAvailability.accountId, account.id))
+      .all();
+    
+    expect(models).toHaveLength(2);
+    const existing = models.find(m => m.modelName === 'gpt-existing');
+    const newModel = models.find(m => m.modelName === 'gpt-new');
+
+    expect(existing?.isManual).toBe(true); // Should be updated
+    expect(newModel?.isManual).toBe(true);
+  });
+
+  it('fails if account does not exist', async () => {
+    const response = await app.inject({
+      method: 'POST',
+      url: '/api/accounts/999/models/manual',
+      payload: {
+        models: ['gpt-4-manual'],
+      },
+    });
+
+    expect(response.statusCode).toBe(404);
+  });
+});

src/server/routes/api/accounts.skip-model-fetch.test.ts

@@ -0,0 +1,120 @@
+import Fastify, { type FastifyInstance } from 'fastify';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const getModelsMock = vi.fn();
+
+vi.mock('../../services/platforms/index.js', () => ({
+  getAdapter: () => ({
+    getModels: (...args: unknown[]) => getModelsMock(...args),
+  }),
+}));
+
+type DbModule = typeof import('../../db/index.js');
+
+describe('accounts skipModelFetch behavior', () => {
+  let app: FastifyInstance;
+  let db: DbModule['db'];
+  let schema: DbModule['schema'];
+  let dataDir = '';
+
+  beforeAll(async () => {
+    dataDir = mkdtempSync(join(tmpdir(), 'metapi-accounts-skip-model-'));
+    process.env.DATA_DIR = dataDir;
+
+    await import('../../db/migrate.js');
+    const dbModule = await import('../../db/index.js');
+    const routesModule = await import('./accounts.js');
+    db = dbModule.db;
+    schema = dbModule.schema;
+
+    app = Fastify();
+    await app.register(routesModule.accountsRoutes);
+  });
+
+  beforeEach(async () => {
+    getModelsMock.mockReset();
+
+    await db.delete(schema.proxyLogs).run();
+    await db.delete(schema.checkinLogs).run();
+    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.accountTokens).run();
+    await db.delete(schema.accounts).run();
+    await db.delete(schema.sites).run();
+  });
+
+  afterAll(async () => {
+    await app.close();
+    delete process.env.DATA_DIR;
+  });
+
+  it('skips model fetching when skipModelFetch is true under apikey credentialMode', async () => {
+    getModelsMock.mockRejectedValueOnce(new Error('Should not be called'));
+
+    const site = await db.insert(schema.sites).values({
+      name: 'API Key Site',
+      url: 'https://apikey.example.com',
+      platform: 'new-api',
+    }).returning().get();
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/api/accounts',
+      payload: {
+        siteId: site.id,
+        accessToken: 'sk-test-skip-fetch',
+        credentialMode: 'apikey',
+        skipModelFetch: true,
+      },
+    });
+
+    expect(response.statusCode).toBe(200);
+    // getModels is called ONCE asynchronously by refreshModelsForAccount later in the flow
+    expect(getModelsMock).toHaveBeenCalledTimes(1);
+
+    const accounts = await db.select().from(schema.accounts).all();
+    expect(accounts).toHaveLength(1);
+    expect(accounts[0]?.apiToken).toBe('sk-test-skip-fetch');
+    
+    // Model availability should be empty initially (background task might not have populated it yet or failed)
+    const models = await db.select().from(schema.modelAvailability).all();
+    expect(models).toHaveLength(0);
+  });
+
+  it('still calls getModels when skipModelFetch is false', async () => {
+    getModelsMock.mockResolvedValue(['gpt-4']);
+
+    const site = await db.insert(schema.sites).values({
+      name: 'API Key Site',
+      url: 'https://apikey.example.com',
+      platform: 'new-api',
+    }).returning().get();
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/api/accounts',
+      payload: {
+        siteId: site.id,
+        accessToken: 'sk-test-normal-fetch',
+        credentialMode: 'apikey',
+        skipModelFetch: false,
+      },
+    });
+
+    expect(response.statusCode).toBe(200);
+    // getModels is called TWICE: once for block validation, once asynchronously by refreshModelsForAccount
+    expect(getModelsMock).toHaveBeenCalledTimes(2);
+
+    const accounts = await db.select().from(schema.accounts).all();
+    expect(accounts).toHaveLength(1);
+    expect(accounts[0]?.apiToken).toBe('sk-test-normal-fetch');
+
+    // Model availability should be populated since getModels was called (which refreshModels uses later or handled directly)
+    // Actually our POST /api/accounts triggers rebuildTokenRoutesFromAvailability and refreshModelsForAccount asynchronously, so models might not be populated synchronously, but the mock should be called.
+  });
+});

src/server/routes/api/accounts.ts

@@ -954,7 +954,7 @@ export async function accountsRoutes(app: FastifyInstance) {
   );
 
   // Add an account (manual credential input)
-  app.post<{ Body: { siteId: number; username?: string; accessToken: string; apiToken?: string; platformUserId?: number; checkinEnabled?: boolean; credentialMode?: AccountCredentialMode; refreshToken?: string; tokenExpiresAt?: number | string } }>('/api/accounts', async (request, reply) => {
+  app.post<{ Body: { siteId: number; username?: string; accessToken: string; apiToken?: string; platformUserId?: number; checkinEnabled?: boolean; credentialMode?: AccountCredentialMode; refreshToken?: string; tokenExpiresAt?: number | string; skipModelFetch?: boolean } }>('/api/accounts', async (request, reply) => {
     const body = request.body;
     const site = await db.select().from(schema.sites).where(eq(schema.sites.id, body.siteId)).get();
     if (!site) {
@@ -979,29 +979,35 @@ export async function accountsRoutes(app: FastifyInstance) {
     let verifiedModels: string[] = [];
 
     if (credentialMode === 'apikey') {
-      try {
-        const models = await adapter.getModels(site.url, rawAccessToken, body.platformUserId);
-        verifiedModels = Array.isArray(models)
-          ? models.filter((item) => typeof item === 'string' && item.trim().length > 0)
-          : [];
-      } catch (err: any) {
-        return reply.code(400).send({
-          success: false,
-          message: err?.message || 'API Key 验证失败',
-        });
-      }
+      if (body.skipModelFetch) {
+        tokenType = 'apikey';
+        accessToken = '';
+        if (!apiToken) apiToken = rawAccessToken;
+      } else {
+        try {
+          const models = await adapter.getModels(site.url, rawAccessToken, body.platformUserId);
+          verifiedModels = Array.isArray(models)
+            ? models.filter((item) => typeof item === 'string' && item.trim().length > 0)
+            : [];
+        } catch (err: any) {
+          return reply.code(400).send({
+            success: false,
+            message: err?.message || 'API Key 验证失败',
+          });
+        }
 
-      if (verifiedModels.length === 0) {
-        return reply.code(400).send({
-          success: false,
-          requiresVerification: true,
-          message: 'API Key 验证失败：未获取到可用模型',
-        });
-      }
+        if (verifiedModels.length === 0) {
+          return reply.code(400).send({
+            success: false,
+            requiresVerification: true,
+            message: 'API Key 验证失败：未获取到可用模型',
+          });
+        }
 
-      tokenType = 'apikey';
-      accessToken = '';
-      if (!apiToken) apiToken = rawAccessToken;
+        tokenType = 'apikey';
+        accessToken = '';
+        if (!apiToken) apiToken = rawAccessToken;
+      }
     } else {
       let verifyResult: any;
       try {
@@ -1367,6 +1373,7 @@ export async function accountsRoutes(app: FastifyInstance) {
       modelName: schema.modelAvailability.modelName,
       available: schema.modelAvailability.available,
       latencyMs: schema.modelAvailability.latencyMs,
+      isManual: schema.modelAvailability.isManual,
     }).from(schema.modelAvailability)
       .where(eq(schema.modelAvailability.accountId, accountId))
       .all();
@@ -1386,6 +1393,7 @@ export async function accountsRoutes(app: FastifyInstance) {
         name: r.modelName,
         latencyMs: r.latencyMs,
         disabled: disabledSet.has(r.modelName),
+        isManual: !!r.isManual,
       }))
       .sort((a, b) => a.name.localeCompare(b.name));
 
@@ -1397,5 +1405,66 @@ export async function accountsRoutes(app: FastifyInstance) {
       disabledCount: models.filter((m) => m.disabled).length,
     };
   });
+
+  // Add models manually to an account
+  app.post<{ Params: { id: string }; Body: { models: string[] } }>('/api/accounts/:id/models/manual', async (request, reply) => {
+    const accountId = parseInt(request.params.id, 10);
+    if (!Number.isFinite(accountId) || accountId <= 0) {
+      return reply.code(400).send({ message: '账号 ID 无效' });
+    }
+
+    const { models } = request.body;
+    if (!Array.isArray(models) || models.length === 0) {
+      return reply.code(400).send({ message: '模型列表不能为空' });
+    }
+
+    const normalizedModels = models.map(m => String(m).trim()).filter(m => m.length > 0);
+    if (normalizedModels.length === 0) {
+      return reply.code(400).send({ message: '模型列表不能为空' });
+    }
+
+    const account = await db.select().from(schema.accounts)
+      .where(eq(schema.accounts.id, accountId))
+      .get();
+
+    if (!account) {
+      return reply.code(404).send({ message: '账号不存在' });
+    }
+
+    try {
+      for (const modelName of normalizedModels) {
+        const existing = await db.select()
+          .from(schema.modelAvailability)
+          .where(and(eq(schema.modelAvailability.accountId, accountId), eq(schema.modelAvailability.modelName, modelName)))
+          .get();
+
+        if (existing) {
+          if (!existing.available || !existing.isManual) {
+            await db.update(schema.modelAvailability)
+              .set({ available: true, latencyMs: null, isManual: true, checkedAt: new Date().toISOString() })
+              .where(eq(schema.modelAvailability.id, existing.id))
+              .run();
+          }
+        } else {
+          await db.insert(schema.modelAvailability).values({
+            accountId,
+            modelName,
+            available: true,
+            isManual: true,
+            latencyMs: null,
+            checkedAt: new Date().toISOString(),
+          }).run();
+        }
+      }
+
+      try {
+        await rebuildTokenRoutesFromAvailability();
+      } catch { }
+
+      return { success: true };
+    } catch (err: any) {
+      return reply.code(500).send({ success: false, message: err?.message || '保存失败' });
+    }
+  });
 }
 

src/server/routes/proxy/models.test.ts

@@ -352,6 +352,12 @@ describe('/v1/models route', () => {
       },
     ]).run();
 
+    await db.insert(schema.downstreamApiKeys).values({
+      name: 'search-key',
+      key: 'change-me-proxy-sk-token',
+      enabled: true,
+    }).run();
+
     const response = await app.inject({
       method: 'GET',
       url: '/v1/models',