Nvidia/BossAI
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add round robin routing and improve token binding UX

Browse Source
This commit is contained in:
bnvnvnv
2026-03-12 05:17:10 +00:00
parent cb93b28c71
commit 5a7531f635
20 changed files with 1112 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/server/db/index.ts
+16
View File
@@ -415,9 +415,25 @@ function ensureRouteGroupingSchema() {
sqlite.exec(`ALTER TABLE token_routes ADD COLUMN decision_refreshed_at text;`);
}
if (!tableColumnExists('token_routes', 'routing_strategy')) {
sqlite.exec(`ALTER TABLE token_routes ADD COLUMN routing_strategy text DEFAULT 'weighted';`);
}
if (!tableColumnExists('route_channels', 'source_model')) {
sqlite.exec(`ALTER TABLE route_channels ADD COLUMN source_model text;`);
}
if (!tableColumnExists('route_channels', 'last_selected_at')) {
sqlite.exec(`ALTER TABLE route_channels ADD COLUMN last_selected_at text;`);
}
if (!tableColumnExists('route_channels', 'consecutive_fail_count')) {
sqlite.exec(`ALTER TABLE route_channels ADD COLUMN consecutive_fail_count integer DEFAULT 0;`);
}
if (!tableColumnExists('route_channels', 'cooldown_level')) {
sqlite.exec(`ALTER TABLE route_channels ADD COLUMN cooldown_level integer DEFAULT 0;`);
}
}
function ensureDownstreamApiKeySchema() {
src/server/db/routeGroupingSchemaCompatibility.test.ts
+10 -2
View File
@@ -44,7 +44,11 @@ describe('ensureRouteGroupingSchemaCompatibility', () => {
'ALTER TABLE "token_routes" ADD COLUMN "display_icon" TEXT',
'ALTER TABLE "token_routes" ADD COLUMN "decision_snapshot" TEXT',
'ALTER TABLE "token_routes" ADD COLUMN "decision_refreshed_at" TEXT',
'ALTER TABLE "token_routes" ADD COLUMN "routing_strategy" TEXT DEFAULT \'weighted\'',
'ALTER TABLE "route_channels" ADD COLUMN "source_model" TEXT',
'ALTER TABLE "route_channels" ADD COLUMN "last_selected_at" TEXT',
'ALTER TABLE "route_channels" ADD COLUMN "consecutive_fail_count" INTEGER DEFAULT 0',
'ALTER TABLE "route_channels" ADD COLUMN "cooldown_level" INTEGER DEFAULT 0',
],
},
{
@@ -54,7 +58,11 @@ describe('ensureRouteGroupingSchemaCompatibility', () => {
'ALTER TABLE `token_routes` ADD COLUMN `display_icon` TEXT NULL',
'ALTER TABLE `token_routes` ADD COLUMN `decision_snapshot` TEXT NULL',
'ALTER TABLE `token_routes` ADD COLUMN `decision_refreshed_at` TEXT NULL',
'ALTER TABLE `token_routes` ADD COLUMN `routing_strategy` VARCHAR(32) NULL DEFAULT \'weighted\'',
'ALTER TABLE `route_channels` ADD COLUMN `source_model` TEXT NULL',
'ALTER TABLE `route_channels` ADD COLUMN `last_selected_at` TEXT NULL',
'ALTER TABLE `route_channels` ADD COLUMN `consecutive_fail_count` INT NOT NULL DEFAULT 0',
'ALTER TABLE `route_channels` ADD COLUMN `cooldown_level` INT NOT NULL DEFAULT 0',
],
},
])('adds missing route grouping columns for $dialect', async ({ dialect, expectedSql }) => {
@@ -68,8 +76,8 @@ describe('ensureRouteGroupingSchemaCompatibility', () => {
it('skips existing columns', async () => {
const { inspector, executedSql } = createInspector('postgres', {
existingColumnsByTable: {
token_routes: ['display_name', 'display_icon', 'decision_snapshot', 'decision_refreshed_at'],
route_channels: ['source_model'],
token_routes: ['display_name', 'display_icon', 'decision_snapshot', 'decision_refreshed_at', 'routing_strategy'],
route_channels: ['source_model', 'last_selected_at', 'consecutive_fail_count', 'cooldown_level'],
},
});
src/server/db/routeGroupingSchemaCompatibility.ts
+36
View File
@@ -50,6 +50,15 @@ const ROUTE_GROUPING_COLUMN_COMPATIBILITY_SPECS: RouteGroupingColumnCompatibilit
postgres: 'ALTER TABLE "token_routes" ADD COLUMN "decision_refreshed_at" TEXT',
},
},
{
table: 'token_routes',
column: 'routing_strategy',
addSql: {
sqlite: 'ALTER TABLE token_routes ADD COLUMN routing_strategy text DEFAULT \'weighted\';',
mysql: 'ALTER TABLE `token_routes` ADD COLUMN `routing_strategy` VARCHAR(32) NULL DEFAULT \'weighted\'',
postgres: 'ALTER TABLE "token_routes" ADD COLUMN "routing_strategy" TEXT DEFAULT \'weighted\'',
},
},
{
table: 'route_channels',
column: 'source_model',
@@ -59,6 +68,33 @@ const ROUTE_GROUPING_COLUMN_COMPATIBILITY_SPECS: RouteGroupingColumnCompatibilit
postgres: 'ALTER TABLE "route_channels" ADD COLUMN "source_model" TEXT',
},
},
{
table: 'route_channels',
column: 'last_selected_at',
addSql: {
sqlite: 'ALTER TABLE route_channels ADD COLUMN last_selected_at text;',
mysql: 'ALTER TABLE `route_channels` ADD COLUMN `last_selected_at` TEXT NULL',
postgres: 'ALTER TABLE "route_channels" ADD COLUMN "last_selected_at" TEXT',
},
},
{
table: 'route_channels',
column: 'consecutive_fail_count',
addSql: {
sqlite: 'ALTER TABLE route_channels ADD COLUMN consecutive_fail_count integer DEFAULT 0;',
mysql: 'ALTER TABLE `route_channels` ADD COLUMN `consecutive_fail_count` INT NOT NULL DEFAULT 0',
postgres: 'ALTER TABLE "route_channels" ADD COLUMN "consecutive_fail_count" INTEGER DEFAULT 0',
},
},
{
table: 'route_channels',
column: 'cooldown_level',
addSql: {
sqlite: 'ALTER TABLE route_channels ADD COLUMN cooldown_level integer DEFAULT 0;',
mysql: 'ALTER TABLE `route_channels` ADD COLUMN `cooldown_level` INT NOT NULL DEFAULT 0',
postgres: 'ALTER TABLE "route_channels" ADD COLUMN "cooldown_level" INTEGER DEFAULT 0',
},
},
];
function normalizeSchemaErrorMessage(error: unknown): string {
src/server/db/runtimeSchemaBootstrap.ts
+6 -6
View File
@@ -192,8 +192,8 @@ export async function ensureRuntimeDatabaseSchema(client: RuntimeSchemaClient):
`CREATE TABLE IF NOT EXISTS "checkin_logs" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "status" TEXT NOT NULL, "message" TEXT, "reward" TEXT, "created_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "model_availability" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "model_name" TEXT NOT NULL, "available" BOOLEAN, "latency_ms" INTEGER, "checked_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "token_model_availability" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "token_id" INTEGER NOT NULL REFERENCES "account_tokens"("id") ON DELETE CASCADE, "model_name" TEXT NOT NULL, "available" BOOLEAN, "latency_ms" INTEGER, "checked_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "token_routes" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "model_pattern" TEXT NOT NULL, "display_name" TEXT, "display_icon" TEXT, "model_mapping" TEXT, "decision_snapshot" TEXT, "decision_refreshed_at" TEXT, "enabled" BOOLEAN DEFAULT TRUE, "created_at" TEXT, "updated_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "route_channels" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "route_id" INTEGER NOT NULL REFERENCES "token_routes"("id") ON DELETE CASCADE, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "token_id" INTEGER REFERENCES "account_tokens"("id") ON DELETE SET NULL, "source_model" TEXT, "priority" INTEGER DEFAULT 0, "weight" INTEGER DEFAULT 10, "enabled" BOOLEAN DEFAULT TRUE, "manual_override" BOOLEAN DEFAULT FALSE, "success_count" INTEGER DEFAULT 0, "fail_count" INTEGER DEFAULT 0, "total_latency_ms" INTEGER DEFAULT 0, "total_cost" DOUBLE PRECISION DEFAULT 0, "last_used_at" TEXT, "last_fail_at" TEXT, "cooldown_until" TEXT)`,
`CREATE TABLE IF NOT EXISTS "token_routes" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "model_pattern" TEXT NOT NULL, "display_name" TEXT, "display_icon" TEXT, "model_mapping" TEXT, "decision_snapshot" TEXT, "decision_refreshed_at" TEXT, "routing_strategy" TEXT DEFAULT 'weighted', "enabled" BOOLEAN DEFAULT TRUE, "created_at" TEXT, "updated_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "route_channels" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "route_id" INTEGER NOT NULL REFERENCES "token_routes"("id") ON DELETE CASCADE, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "token_id" INTEGER REFERENCES "account_tokens"("id") ON DELETE SET NULL, "source_model" TEXT, "priority" INTEGER DEFAULT 0, "weight" INTEGER DEFAULT 10, "enabled" BOOLEAN DEFAULT TRUE, "manual_override" BOOLEAN DEFAULT FALSE, "success_count" INTEGER DEFAULT 0, "fail_count" INTEGER DEFAULT 0, "total_latency_ms" INTEGER DEFAULT 0, "total_cost" DOUBLE PRECISION DEFAULT 0, "last_used_at" TEXT, "last_selected_at" TEXT, "last_fail_at" TEXT, "consecutive_fail_count" INTEGER DEFAULT 0, "cooldown_level" INTEGER DEFAULT 0, "cooldown_until" TEXT)`,
`CREATE TABLE IF NOT EXISTS "proxy_logs" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY 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, "billing_details" TEXT, "error_message" TEXT, "retry_count" INTEGER DEFAULT 0, "created_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "proxy_video_tasks" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "public_id" TEXT NOT NULL UNIQUE, "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" TEXT, "upstream_response_meta" TEXT, "last_upstream_status" INTEGER, "last_polled_at" TEXT, "created_at" TEXT, "updated_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "proxy_files" ("id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "public_id" TEXT NOT NULL UNIQUE, "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" TEXT, "updated_at" TEXT, "deleted_at" TEXT)`,
@@ -209,8 +209,8 @@ export async function ensureRuntimeDatabaseSchema(client: RuntimeSchemaClient):
`CREATE TABLE IF NOT EXISTS \`checkin_logs\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`account_id\` INT NOT NULL, \`status\` VARCHAR(32) NOT NULL, \`message\` TEXT NULL, \`reward\` TEXT NULL, \`created_at\` TEXT NULL, CONSTRAINT \`checkin_logs_account_fk\` FOREIGN KEY (\`account_id\`) REFERENCES \`accounts\`(\`id\`) ON DELETE CASCADE)`,
`CREATE TABLE IF NOT EXISTS \`model_availability\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`account_id\` INT NOT NULL, \`model_name\` VARCHAR(191) NOT NULL, \`available\` BOOLEAN NULL, \`latency_ms\` INT NULL, \`checked_at\` TEXT NULL, CONSTRAINT \`model_availability_account_fk\` FOREIGN KEY (\`account_id\`) REFERENCES \`accounts\`(\`id\`) ON DELETE CASCADE)`,
`CREATE TABLE IF NOT EXISTS \`token_model_availability\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`token_id\` INT NOT NULL, \`model_name\` VARCHAR(191) NOT NULL, \`available\` BOOLEAN NULL, \`latency_ms\` INT NULL, \`checked_at\` TEXT NULL, CONSTRAINT \`token_model_availability_token_fk\` FOREIGN KEY (\`token_id\`) REFERENCES \`account_tokens\`(\`id\`) ON DELETE CASCADE)`,
`CREATE TABLE IF NOT EXISTS \`token_routes\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`model_pattern\` TEXT NOT NULL, \`display_name\` TEXT NULL, \`display_icon\` TEXT NULL, \`model_mapping\` TEXT NULL, \`decision_snapshot\` TEXT NULL, \`decision_refreshed_at\` TEXT NULL, \`enabled\` BOOLEAN DEFAULT TRUE, \`created_at\` TEXT NULL, \`updated_at\` TEXT NULL)`,
`CREATE TABLE IF NOT EXISTS \`route_channels\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`route_id\` INT NOT NULL, \`account_id\` INT NOT NULL, \`token_id\` INT NULL, \`source_model\` TEXT NULL, \`priority\` INT DEFAULT 0, \`weight\` INT DEFAULT 10, \`enabled\` BOOLEAN DEFAULT TRUE, \`manual_override\` BOOLEAN DEFAULT FALSE, \`success_count\` INT DEFAULT 0, \`fail_count\` INT DEFAULT 0, \`total_latency_ms\` INT DEFAULT 0, \`total_cost\` DOUBLE DEFAULT 0, \`last_used_at\` TEXT NULL, \`last_fail_at\` TEXT NULL, \`cooldown_until\` TEXT NULL, CONSTRAINT \`route_channels_route_fk\` FOREIGN KEY (\`route_id\`) REFERENCES \`token_routes\`(\`id\`) ON DELETE CASCADE, CONSTRAINT \`route_channels_account_fk\` FOREIGN KEY (\`account_id\`) REFERENCES \`accounts\`(\`id\`) ON DELETE CASCADE, CONSTRAINT \`route_channels_token_fk\` FOREIGN KEY (\`token_id\`) REFERENCES \`account_tokens\`(\`id\`) ON DELETE SET NULL)`,
`CREATE TABLE IF NOT EXISTS \`token_routes\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`model_pattern\` TEXT NOT NULL, \`display_name\` TEXT NULL, \`display_icon\` TEXT NULL, \`model_mapping\` TEXT NULL, \`decision_snapshot\` TEXT NULL, \`decision_refreshed_at\` TEXT NULL, \`routing_strategy\` VARCHAR(32) NULL DEFAULT 'weighted', \`enabled\` BOOLEAN DEFAULT TRUE, \`created_at\` TEXT NULL, \`updated_at\` TEXT NULL)`,
`CREATE TABLE IF NOT EXISTS \`route_channels\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`route_id\` INT NOT NULL, \`account_id\` INT NOT NULL, \`token_id\` INT NULL, \`source_model\` TEXT NULL, \`priority\` INT DEFAULT 0, \`weight\` INT DEFAULT 10, \`enabled\` BOOLEAN DEFAULT TRUE, \`manual_override\` BOOLEAN DEFAULT FALSE, \`success_count\` INT DEFAULT 0, \`fail_count\` INT DEFAULT 0, \`total_latency_ms\` INT DEFAULT 0, \`total_cost\` DOUBLE DEFAULT 0, \`last_used_at\` TEXT NULL, \`last_selected_at\` TEXT NULL, \`last_fail_at\` TEXT NULL, \`consecutive_fail_count\` INT DEFAULT 0, \`cooldown_level\` INT DEFAULT 0, \`cooldown_until\` TEXT NULL, CONSTRAINT \`route_channels_route_fk\` FOREIGN KEY (\`route_id\`) REFERENCES \`token_routes\`(\`id\`) ON DELETE CASCADE, CONSTRAINT \`route_channels_account_fk\` FOREIGN KEY (\`account_id\`) REFERENCES \`accounts\`(\`id\`) ON DELETE CASCADE, CONSTRAINT \`route_channels_token_fk\` FOREIGN KEY (\`token_id\`) REFERENCES \`account_tokens\`(\`id\`) ON DELETE SET NULL)`,
`CREATE TABLE IF NOT EXISTS \`proxy_logs\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`route_id\` INT NULL, \`channel_id\` INT NULL, \`account_id\` INT NULL, \`model_requested\` TEXT NULL, \`model_actual\` TEXT NULL, \`status\` VARCHAR(32) NULL, \`http_status\` INT NULL, \`latency_ms\` INT NULL, \`prompt_tokens\` INT NULL, \`completion_tokens\` INT NULL, \`total_tokens\` INT NULL, \`estimated_cost\` DOUBLE NULL, \`billing_details\` TEXT NULL, \`error_message\` TEXT NULL, \`retry_count\` INT DEFAULT 0, \`created_at\` TEXT NULL)`,
`CREATE TABLE IF NOT EXISTS \`proxy_video_tasks\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`public_id\` VARCHAR(191) NOT NULL UNIQUE, \`upstream_video_id\` TEXT NOT NULL, \`site_url\` TEXT NOT NULL, \`token_value\` TEXT NOT NULL, \`requested_model\` TEXT NULL, \`actual_model\` TEXT NULL, \`channel_id\` INT NULL, \`account_id\` INT NULL, \`status_snapshot\` TEXT NULL, \`upstream_response_meta\` TEXT NULL, \`last_upstream_status\` INT NULL, \`last_polled_at\` TEXT NULL, \`created_at\` TEXT NULL, \`updated_at\` TEXT NULL)`,
`CREATE TABLE IF NOT EXISTS \`proxy_files\` (\`id\` INT AUTO_INCREMENT PRIMARY KEY, \`public_id\` VARCHAR(191) NOT NULL UNIQUE, \`owner_type\` VARCHAR(64) NOT NULL, \`owner_id\` VARCHAR(191) NOT NULL, \`filename\` TEXT NOT NULL, \`mime_type\` VARCHAR(191) NOT NULL, \`purpose\` TEXT NULL, \`byte_size\` INT NOT NULL, \`sha256\` VARCHAR(191) NOT NULL, \`content_base64\` LONGTEXT NOT NULL, \`created_at\` TEXT NULL, \`updated_at\` TEXT NULL, \`deleted_at\` TEXT NULL)`,
@@ -225,8 +225,8 @@ export async function ensureRuntimeDatabaseSchema(client: RuntimeSchemaClient):
`CREATE TABLE IF NOT EXISTS "checkin_logs" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "status" TEXT NOT NULL, "message" TEXT, "reward" TEXT, "created_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "model_availability" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "model_name" TEXT NOT NULL, "available" INTEGER, "latency_ms" INTEGER, "checked_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "token_model_availability" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "token_id" INTEGER NOT NULL REFERENCES "account_tokens"("id") ON DELETE CASCADE, "model_name" TEXT NOT NULL, "available" INTEGER, "latency_ms" INTEGER, "checked_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "token_routes" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "model_pattern" TEXT NOT NULL, "display_name" TEXT, "display_icon" TEXT, "model_mapping" TEXT, "decision_snapshot" TEXT, "decision_refreshed_at" TEXT, "enabled" INTEGER DEFAULT 1, "created_at" TEXT, "updated_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "route_channels" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "route_id" INTEGER NOT NULL REFERENCES "token_routes"("id") ON DELETE CASCADE, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "token_id" INTEGER REFERENCES "account_tokens"("id") ON DELETE SET NULL, "source_model" TEXT, "priority" INTEGER DEFAULT 0, "weight" INTEGER DEFAULT 10, "enabled" INTEGER DEFAULT 1, "manual_override" INTEGER DEFAULT 0, "success_count" INTEGER DEFAULT 0, "fail_count" INTEGER DEFAULT 0, "total_latency_ms" INTEGER DEFAULT 0, "total_cost" REAL DEFAULT 0, "last_used_at" TEXT, "last_fail_at" TEXT, "cooldown_until" TEXT)`,
`CREATE TABLE IF NOT EXISTS "token_routes" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "model_pattern" TEXT NOT NULL, "display_name" TEXT, "display_icon" TEXT, "model_mapping" TEXT, "decision_snapshot" TEXT, "decision_refreshed_at" TEXT, "routing_strategy" TEXT DEFAULT 'weighted', "enabled" INTEGER DEFAULT 1, "created_at" TEXT, "updated_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "route_channels" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "route_id" INTEGER NOT NULL REFERENCES "token_routes"("id") ON DELETE CASCADE, "account_id" INTEGER NOT NULL REFERENCES "accounts"("id") ON DELETE CASCADE, "token_id" INTEGER REFERENCES "account_tokens"("id") ON DELETE SET NULL, "source_model" TEXT, "priority" INTEGER DEFAULT 0, "weight" INTEGER DEFAULT 10, "enabled" INTEGER DEFAULT 1, "manual_override" INTEGER DEFAULT 0, "success_count" INTEGER DEFAULT 0, "fail_count" INTEGER DEFAULT 0, "total_latency_ms" INTEGER DEFAULT 0, "total_cost" REAL DEFAULT 0, "last_used_at" TEXT, "last_selected_at" TEXT, "last_fail_at" TEXT, "consecutive_fail_count" INTEGER DEFAULT 0, "cooldown_level" INTEGER DEFAULT 0, "cooldown_until" TEXT)`,
`CREATE TABLE IF NOT EXISTS "proxy_logs" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "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" REAL, "billing_details" TEXT, "error_message" TEXT, "retry_count" INTEGER DEFAULT 0, "created_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "proxy_video_tasks" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "public_id" TEXT NOT NULL UNIQUE, "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" TEXT, "upstream_response_meta" TEXT, "last_upstream_status" INTEGER, "last_polled_at" TEXT, "created_at" TEXT, "updated_at" TEXT)`,
`CREATE TABLE IF NOT EXISTS "proxy_files" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "public_id" TEXT NOT NULL UNIQUE, "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" TEXT, "updated_at" TEXT, "deleted_at" TEXT)`,
src/server/db/schema.ts
+4
View File
@@ -111,6 +111,7 @@ export const tokenRoutes = sqliteTable('token_routes', {
modelMapping: text('model_mapping'), // JSON
decisionSnapshot: text('decision_snapshot'), // JSON
decisionRefreshedAt: text('decision_refreshed_at'),
routingStrategy: text('routing_strategy').default('weighted'),
enabled: integer('enabled', { mode: 'boolean' }).default(true),
createdAt: text('created_at').default(sql`(datetime('now'))`),
updatedAt: text('updated_at').default(sql`(datetime('now'))`),
@@ -134,7 +135,10 @@ export const routeChannels = sqliteTable('route_channels', {
totalLatencyMs: integer('total_latency_ms').default(0),
totalCost: real('total_cost').default(0),
lastUsedAt: text('last_used_at'),
lastSelectedAt: text('last_selected_at'),
lastFailAt: text('last_fail_at'),
consecutiveFailCount: integer('consecutive_fail_count').default(0),
cooldownLevel: integer('cooldown_level').default(0),
cooldownUntil: text('cooldown_until'),
}, (table) => ({
routeIdIdx: index('route_channels_route_id_idx').on(table.routeId),
src/server/routes/api/settings.ts
+3
View File
@@ -882,7 +882,10 @@ export async function settingsRoutes(app: FastifyInstance) {
totalLatencyMs: 0,
totalCost: 0,
lastUsedAt: null,
lastSelectedAt: null,
lastFailAt: null,
consecutiveFailCount: 0,
cooldownLevel: 0,
cooldownUntil: null,
}).run();
src/server/routes/api/tokens.ts
+10 -2
View File
@@ -2,6 +2,7 @@
import { and, eq, inArray } from 'drizzle-orm';
import { db, schema } from '../../db/index.js';
import { rebuildTokenRoutesFromAvailability, refreshModelsAndRebuildRoutes } from '../../services/modelService.js';
import { normalizeRouteRoutingStrategy } from '../../services/routeRoutingStrategy.js';
import { invalidateTokenRouterCache, matchesModelPattern, tokenRouter } from '../../services/tokenRouter.js';
import { startBackgroundTask } from '../../services/backgroundTaskService.js';
import {
@@ -420,6 +421,7 @@ export async function tokensRoutes(app: FastifyInstance) {
modelPattern: schema.tokenRoutes.modelPattern,
displayName: schema.tokenRoutes.displayName,
displayIcon: schema.tokenRoutes.displayIcon,
routingStrategy: schema.tokenRoutes.routingStrategy,
enabled: schema.tokenRoutes.enabled,
}).from(schema.tokenRoutes).all();
});
@@ -462,6 +464,7 @@ export async function tokensRoutes(app: FastifyInstance) {
displayName: route.displayName ?? null,
displayIcon: route.displayIcon ?? null,
modelMapping: route.modelMapping ?? null,
routingStrategy: route.routingStrategy ?? 'weighted',
enabled: route.enabled,
channelCount: agg?.channelCount ?? 0,
enabledChannelCount: agg?.enabledChannelCount ?? 0,
@@ -676,13 +679,14 @@ export async function tokensRoutes(app: FastifyInstance) {
});
// Create a route
app.post<{ Body: { modelPattern: string; displayName?: string; displayIcon?: string; modelMapping?: string; enabled?: boolean } }>('/api/routes', async (request) => {
app.post<{ Body: { modelPattern: string; displayName?: string; displayIcon?: string; modelMapping?: string; routingStrategy?: string; enabled?: boolean } }>('/api/routes', async (request) => {
const body = request.body;
const insertedRoute = await db.insert(schema.tokenRoutes).values({
modelPattern: body.modelPattern,
displayName: body.displayName,
displayIcon: body.displayIcon,
modelMapping: body.modelMapping,
routingStrategy: normalizeRouteRoutingStrategy(body.routingStrategy),
enabled: body.enabled ?? true,
}).run();
const routeId = Number(insertedRoute.lastInsertRowid || 0);
@@ -718,12 +722,16 @@ export async function tokensRoutes(app: FastifyInstance) {
updates.modelPattern = nextModelPattern;
}
if (body.modelMapping !== undefined) updates.modelMapping = body.modelMapping;
if (body.routingStrategy !== undefined) updates.routingStrategy = normalizeRouteRoutingStrategy(body.routingStrategy);
if (body.enabled !== undefined) updates.enabled = body.enabled;
updates.updatedAt = new Date().toISOString();
await db.update(schema.tokenRoutes).set(updates).where(eq(schema.tokenRoutes.id, id)).run();
const modelPatternChanged = body.modelPattern !== undefined && nextModelPattern !== existingRoute.modelPattern;
const routeBehaviorChanged = modelPatternChanged || body.modelMapping !== undefined || body.enabled !== undefined;
const routeBehaviorChanged = modelPatternChanged
|| body.modelMapping !== undefined
|| body.routingStrategy !== undefined
|| body.enabled !== undefined;
if (modelPatternChanged) {
await rebuildAutomaticRouteChannelsByModelPattern(id, nextModelPattern);
}
src/server/services/databaseMigrationService.ts
+6 -2
View File
@@ -374,7 +374,7 @@ function buildStatements(snapshot: BackupSnapshot): InsertStatement[] {
for (const row of snapshot.accounts.tokenRoutes) {
statements.push({
table: 'token_routes',
columns: ['id', 'model_pattern', 'display_name', 'display_icon', 'model_mapping', 'decision_snapshot', 'decision_refreshed_at', 'enabled', 'created_at', 'updated_at'],
columns: ['id', 'model_pattern', 'display_name', 'display_icon', 'model_mapping', 'decision_snapshot', 'decision_refreshed_at', 'routing_strategy', 'enabled', 'created_at', 'updated_at'],
values: [
asNumber(row.id, 0),
asNullableString(row.modelPattern),
@@ -383,6 +383,7 @@ function buildStatements(snapshot: BackupSnapshot): InsertStatement[] {
asNullableString(row.modelMapping),
asNullableString(row.decisionSnapshot),
asNullableString(row.decisionRefreshedAt),
asNullableString(row.routingStrategy),
asBoolean(row.enabled, true),
asNullableString(row.createdAt),
asNullableString(row.updatedAt),
@@ -393,7 +394,7 @@ function buildStatements(snapshot: BackupSnapshot): InsertStatement[] {
for (const row of snapshot.accounts.routeChannels) {
statements.push({
table: 'route_channels',
columns: ['id', 'route_id', 'account_id', 'token_id', 'source_model', 'priority', 'weight', 'enabled', 'manual_override', 'success_count', 'fail_count', 'total_latency_ms', 'total_cost', 'last_used_at', 'last_fail_at', 'cooldown_until'],
columns: ['id', 'route_id', 'account_id', 'token_id', 'source_model', 'priority', 'weight', 'enabled', 'manual_override', 'success_count', 'fail_count', 'total_latency_ms', 'total_cost', 'last_used_at', 'last_selected_at', 'last_fail_at', 'consecutive_fail_count', 'cooldown_level', 'cooldown_until'],
values: [
asNumber(row.id, 0),
asNumber(row.routeId, 0),
@@ -409,7 +410,10 @@ function buildStatements(snapshot: BackupSnapshot): InsertStatement[] {
asNumber(row.totalLatencyMs, 0),
asNumber(row.totalCost, 0),
asNullableString(row.lastUsedAt),
asNullableString(row.lastSelectedAt),
asNullableString(row.lastFailAt),
asNumber(row.consecutiveFailCount, 0),
asNumber(row.cooldownLevel, 0),
asNullableString(row.cooldownUntil),
],
});
src/server/services/routeRoutingStrategy.ts
+13
View File
@@ -0,0 +1,13 @@
export type RouteRoutingStrategy = 'weighted' | 'round_robin';
export const DEFAULT_ROUTE_ROUTING_STRATEGY: RouteRoutingStrategy = 'weighted';
export function normalizeRouteRoutingStrategy(value: unknown): RouteRoutingStrategy {
const normalized = String(value || '').trim().toLowerCase();
if (normalized === 'round_robin') return 'round_robin';
return DEFAULT_ROUTE_ROUTING_STRATEGY;
}
export function isRoundRobinRouteRoutingStrategy(value: unknown): boolean {
return normalizeRouteRoutingStrategy(value) === 'round_robin';
}
src/server/services/tokenRouter.cache.test.ts
+151
View File
@@ -127,6 +127,7 @@ describe('TokenRouter runtime cache', () => {
const route = await db.insert(schema.tokenRoutes).values({
modelPattern: 'gpt-4o-mini',
routingStrategy: 'weighted',
enabled: true,
}).returning().get();
@@ -168,4 +169,154 @@ describe('TokenRouter runtime cache', () => {
expect(thirdCooldownMs).toBeGreaterThanOrEqual(25_000);
expect(thirdCooldownMs).toBeLessThanOrEqual(35_000);
});
it('round robins across all available channels regardless of priority', async () => {
const site = await db.insert(schema.sites).values({
name: 'round-robin-site',
url: 'https://round-robin-site.example.com',
platform: 'new-api',
status: 'active',
}).returning().get();
const account = await db.insert(schema.accounts).values({
siteId: site.id,
username: 'round-robin-user',
accessToken: 'round-robin-access-token',
apiToken: 'round-robin-api-token',
status: 'active',
}).returning().get();
const token = await db.insert(schema.accountTokens).values({
accountId: account.id,
name: 'round-robin-token',
token: 'sk-round-robin-token',
enabled: true,
isDefault: true,
}).returning().get();
const route = await db.insert(schema.tokenRoutes).values({
modelPattern: 'gpt-4o-mini',
routingStrategy: 'round_robin',
enabled: true,
}).returning().get();
const channels = await db.insert(schema.routeChannels).values([
{ routeId: route.id, accountId: account.id, tokenId: token.id, priority: 0, weight: 10, enabled: true },
{ routeId: route.id, accountId: account.id, tokenId: token.id, priority: 3, weight: 10, enabled: true },
{ routeId: route.id, accountId: account.id, tokenId: token.id, priority: 9, weight: 10, enabled: true },
]).returning().all();
const router = new TokenRouter();
const first = await router.selectChannel('gpt-4o-mini');
const second = await router.selectChannel('gpt-4o-mini');
const third = await router.selectChannel('gpt-4o-mini');
const fourth = await router.selectChannel('gpt-4o-mini');
expect(first?.channel.id).toBe(channels[0].id);
expect(second?.channel.id).toBe(channels[1].id);
expect(third?.channel.id).toBe(channels[2].id);
expect(fourth?.channel.id).toBe(channels[0].id);
});
it('applies staged cooldowns for round robin after every three consecutive failures', async () => {
const site = await db.insert(schema.sites).values({
name: 'round-robin-cooldown-site',
url: 'https://round-robin-cooldown-site.example.com',
platform: 'new-api',
status: 'active',
}).returning().get();
const account = await db.insert(schema.accounts).values({
siteId: site.id,
username: 'round-robin-cooldown-user',
accessToken: 'round-robin-cooldown-access-token',
apiToken: 'round-robin-cooldown-api-token',
status: 'active',
}).returning().get();
const token = await db.insert(schema.accountTokens).values({
accountId: account.id,
name: 'round-robin-cooldown-token',
token: 'sk-round-robin-cooldown-token',
enabled: true,
isDefault: true,
}).returning().get();
const route = await db.insert(schema.tokenRoutes).values({
modelPattern: 'gpt-4o-mini',
routingStrategy: 'round_robin',
enabled: true,
}).returning().get();
const channel = await db.insert(schema.routeChannels).values({
routeId: route.id,
accountId: account.id,
tokenId: token.id,
priority: 0,
weight: 10,
enabled: true,
}).returning().get();
const router = new TokenRouter();
for (let index = 0; index < 2; index += 1) {
await router.recordFailure(channel.id);
}
let current = await db.select().from(schema.routeChannels)
.where(eq(schema.routeChannels.id, channel.id))
.get();
expect(current?.cooldownUntil).toBeNull();
expect(current?.consecutiveFailCount).toBe(2);
expect(current?.cooldownLevel).toBe(0);
let startedAt = Date.now();
await router.recordFailure(channel.id);
current = await db.select().from(schema.routeChannels)
.where(eq(schema.routeChannels.id, channel.id))
.get();
let cooldownMs = Date.parse(String(current?.cooldownUntil || '')) - startedAt;
expect(current?.consecutiveFailCount).toBe(0);
expect(current?.cooldownLevel).toBe(1);
expect(cooldownMs).toBeGreaterThanOrEqual(9 * 60 * 1000);
expect(cooldownMs).toBeLessThanOrEqual(11 * 60 * 1000);
await db.update(schema.routeChannels).set({ cooldownUntil: null }).where(eq(schema.routeChannels.id, channel.id)).run();
for (let index = 0; index < 2; index += 1) {
await router.recordFailure(channel.id);
}
startedAt = Date.now();
await router.recordFailure(channel.id);
current = await db.select().from(schema.routeChannels)
.where(eq(schema.routeChannels.id, channel.id))
.get();
cooldownMs = Date.parse(String(current?.cooldownUntil || '')) - startedAt;
expect(current?.cooldownLevel).toBe(2);
expect(cooldownMs).toBeGreaterThanOrEqual(59 * 60 * 1000);
expect(cooldownMs).toBeLessThanOrEqual(61 * 60 * 1000);
await db.update(schema.routeChannels).set({ cooldownUntil: null }).where(eq(schema.routeChannels.id, channel.id)).run();
for (let index = 0; index < 2; index += 1) {
await router.recordFailure(channel.id);
}
startedAt = Date.now();
await router.recordFailure(channel.id);
current = await db.select().from(schema.routeChannels)
.where(eq(schema.routeChannels.id, channel.id))
.get();
cooldownMs = Date.parse(String(current?.cooldownUntil || '')) - startedAt;
expect(current?.cooldownLevel).toBe(3);
expect(cooldownMs).toBeGreaterThanOrEqual(23 * 60 * 60 * 1000);
expect(cooldownMs).toBeLessThanOrEqual(25 * 60 * 60 * 1000);
await router.recordSuccess(channel.id, 320, 0.12);
current = await db.select().from(schema.routeChannels)
.where(eq(schema.routeChannels.id, channel.id))
.get();
expect(current?.consecutiveFailCount).toBe(0);
expect(current?.cooldownLevel).toBe(0);
expect(current?.cooldownUntil).toBeNull();
});
});
src/server/services/tokenRouter.ts
+259 -126
View File
@@ -3,6 +3,11 @@ import { minimatch } from 'minimatch';
import { db, schema } from '../db/index.js';
import { config } from '../config.js';
import { getCachedModelRoutingReferenceCost, refreshModelPricingCatalog } from './modelPricingService.js';
import {
DEFAULT_ROUTE_ROUTING_STRATEGY,
normalizeRouteRoutingStrategy,
type RouteRoutingStrategy,
} from './routeRoutingStrategy.js';
import { type DownstreamRoutingPolicy, EMPTY_DOWNSTREAM_ROUTING_POLICY } from './downstreamPolicyTypes.js';
interface RouteMatch {
@@ -34,6 +39,8 @@ type FailureAwareChannel = {
const FAILURE_BACKOFF_BASE_SEC = 15;
const MIN_EFFECTIVE_UNIT_COST = 1e-6;
const ROUND_ROBIN_FAILURE_THRESHOLD = 3;
const ROUND_ROBIN_COOLDOWN_LEVELS_SEC = [0, 10 * 60, 60 * 60, 24 * 60 * 60] as const;
function fibonacciNumber(index: number): number {
if (index <= 2) return 1;
@@ -52,6 +59,11 @@ function resolveFailureBackoffSec(failCount?: number | null): number {
return FAILURE_BACKOFF_BASE_SEC * fibonacciNumber(normalizedFailCount);
}
function resolveRoundRobinCooldownSec(level: number): number {
const normalizedLevel = Math.max(0, Math.min(ROUND_ROBIN_COOLDOWN_LEVELS_SEC.length - 1, Math.trunc(level)));
return ROUND_ROBIN_COOLDOWN_LEVELS_SEC[normalizedLevel] ?? 0;
}
type RouteRow = typeof schema.tokenRoutes.$inferSelect;
type ChannelRow = typeof schema.routeChannels.$inferSelect;
@@ -357,6 +369,25 @@ function resolveActualModelForSelectedChannel(
return mappedModel;
}
function resolveRouteStrategy(route: typeof schema.tokenRoutes.$inferSelect): RouteRoutingStrategy {
return normalizeRouteRoutingStrategy(route.routingStrategy);
}
function parseIsoTimeMs(value?: string | null): number | null {
if (!value) return null;
const parsed = Date.parse(value);
return Number.isNaN(parsed) ? null : parsed;
}
function compareNullableTimeAsc(left?: string | null, right?: string | null): number {
const leftMs = parseIsoTimeMs(left);
const rightMs = parseIsoTimeMs(right);
if (leftMs == null && rightMs == null) return 0;
if (leftMs == null) return -1;
if (rightMs == null) return 1;
return leftMs - rightMs;
}
function resolveEffectiveUnitCost(candidate: RouteChannelCandidate, modelName: string): CostSignal {
const successCount = Math.max(0, candidate.channel.successCount ?? 0);
const totalCost = Math.max(0, candidate.channel.totalCost ?? 0);
@@ -408,67 +439,7 @@ export class TokenRouter {
const match = await this.findRoute(requestedModel, downstreamPolicy);
if (!match) return null;
const mappedModel = resolveMappedModel(requestedModel, match.route.modelMapping);
const requestedByDisplayName = isRouteDisplayNameMatch(requestedModel, match.route.displayName);
const bypassSourceModelCheck = requestedByDisplayName;
const nowIso = new Date().toISOString();
const nowMs = Date.now();
const available = match.channels.filter((candidate) => (
this.getCandidateEligibilityReasons(candidate, {
requestedModel,
bypassSourceModelCheck,
nowIso,
}).length === 0
));
if (available.length === 0) return null;
// Group by priority
const layers = new Map<number, typeof available>();
for (const c of available) {
const p = c.channel.priority ?? 0;
if (!layers.has(p)) layers.set(p, []);
layers.get(p)!.push(c);
}
// Sort layers by priority (ascending = higher priority first)
const sortedPriorities = Array.from(layers.keys()).sort((a, b) => a - b);
// Try each priority layer
for (const priority of sortedPriorities) {
const candidates = filterRecentlyFailedCandidates(
layers.get(priority)!,
nowMs,
);
const selected = this.weightedRandomSelect(
candidates,
requestedByDisplayName
? (candidate) => normalizeChannelSourceModel(candidate.channel.sourceModel) || mappedModel
: mappedModel,
downstreamPolicy,
);
if (selected) {
const tokenValue = this.resolveChannelTokenValue(selected);
if (!tokenValue) continue;
const actualModel = resolveActualModelForSelectedChannel(
requestedModel,
match.route,
mappedModel,
selected.channel.sourceModel,
);
return {
...selected,
tokenValue,
tokenName: selected.token?.name || 'default',
actualModel,
};
}
}
return null;
return await this.selectFromMatch(match, requestedModel, downstreamPolicy);
}
/**
@@ -483,64 +454,7 @@ export class TokenRouter {
const match = await this.findRoute(requestedModel, downstreamPolicy);
if (!match) return null;
const mappedModel = resolveMappedModel(requestedModel, match.route.modelMapping);
const requestedByDisplayName = isRouteDisplayNameMatch(requestedModel, match.route.displayName);
const bypassSourceModelCheck = requestedByDisplayName;
const nowIso = new Date().toISOString();
const nowMs = Date.now();
const available = match.channels.filter((candidate) => (
this.getCandidateEligibilityReasons(candidate, {
requestedModel,
bypassSourceModelCheck,
excludeChannelIds,
nowIso,
}).length === 0
));
if (available.length === 0) return null;
const layers = new Map<number, typeof available>();
for (const c of available) {
const p = c.channel.priority ?? 0;
if (!layers.has(p)) layers.set(p, []);
layers.get(p)!.push(c);
}
const sortedPriorities = Array.from(layers.keys()).sort((a, b) => a - b);
for (const priority of sortedPriorities) {
const candidates = filterRecentlyFailedCandidates(
layers.get(priority)!,
nowMs,
);
const selected = this.weightedRandomSelect(
candidates,
requestedByDisplayName
? (candidate) => normalizeChannelSourceModel(candidate.channel.sourceModel) || mappedModel
: mappedModel,
downstreamPolicy,
);
if (!selected) continue;
const tokenValue = this.resolveChannelTokenValue(selected);
if (!tokenValue) continue;
const actualModel = resolveActualModelForSelectedChannel(
requestedModel,
match.route,
mappedModel,
selected.channel.sourceModel,
);
return {
...selected,
tokenValue,
tokenName: selected.token?.name || 'default',
actualModel,
};
}
return null;
return await this.selectFromMatch(match, requestedModel, downstreamPolicy, excludeChannelIds);
}
async explainSelection(
@@ -626,10 +540,14 @@ export class TokenRouter {
const bypassSourceModelCheck = (options.bypassSourceModelCheck ?? false) || requestedByDisplayName;
const useChannelSourceModelForCost = (options.useChannelSourceModelForCost ?? false) || requestedByDisplayName;
const mappedModel = resolveMappedModel(requestedModel, match.route.modelMapping);
const routeStrategy = resolveRouteStrategy(match.route);
const nowIso = new Date().toISOString();
const nowMs = Date.now();
const summary: string[] = [`命中路由：${match.route.modelPattern}`];
const summary: string[] = [
`命中路由：${match.route.modelPattern}`,
routeStrategy === 'round_robin' ? '路由策略：轮询' : '路由策略：按权重随机',
];
if (requestedByDisplayName) {
summary.push(`按显示名命中：${normalizeRouteDisplayName(match.route.displayName)}`);
summary.push('显示名仅用于聚合展示，实际转发模型按选中通道来源模型决定');
@@ -646,7 +564,9 @@ export class TokenRouter {
nowIso,
});
const recentlyFailed = isChannelRecentlyFailed(row.channel, nowMs);
const recentlyFailed = routeStrategy === DEFAULT_ROUTE_ROUTING_STRATEGY
? isChannelRecentlyFailed(row.channel, nowMs)
: false;
const eligible = reasonParts.length === 0;
const candidate: RouteDecisionCandidate = {
channelId: row.channel.id,
@@ -685,6 +605,68 @@ export class TokenRouter {
};
}
if (routeStrategy === 'round_robin') {
const ordered = this.getRoundRobinCandidates(match.channels.filter((row) => {
const target = candidateMap.get(row.channel.id);
return !!target?.eligible;
}));
let selected: RouteChannelCandidate | null = null;
for (let index = 0; index < ordered.length; index += 1) {
const target = candidateMap.get(ordered[index].channel.id);
if (!target || !target.eligible) continue;
target.probability = index === 0 ? 100 : 0;
target.reason = index === 0
? `轮询命中（全局第 1 / ${ordered.length} 位，忽略优先级）`
: `轮询排队中（全局第 ${index + 1} / ${ordered.length} 位，忽略优先级）`;
if (index === 0) {
selected = ordered[index];
}
}
if (!selected) {
summary.push('本次未选出通道');
return {
requestedModel,
actualModel: mappedModel,
matched: true,
routeId: match.route.id,
modelPattern: match.route.modelPattern,
summary,
candidates,
};
}
const selectedChannel = candidateMap.get(selected.channel.id);
const selectedLabel = selectedChannel
? `${selectedChannel.username} @ ${selectedChannel.siteName} / ${selectedChannel.tokenName}`
: `channel-${selected.channel.id}`;
const actualModel = resolveActualModelForSelectedChannel(
requestedModel,
match.route,
mappedModel,
selected.channel.sourceModel,
);
summary.push(`全局轮询：可用 ${ordered.length}，忽略优先级`);
summary.push(`最终选择：${selectedLabel}`);
if (actualModel !== mappedModel) {
summary.push(`实际转发模型：${actualModel}`);
}
return {
requestedModel,
actualModel,
matched: true,
routeId: match.route.id,
modelPattern: match.route.modelPattern,
selectedChannelId: selected.channel.id,
selectedAccountId: selected.account.id,
selectedLabel,
summary,
candidates,
};
}
const sortedPriorities = Array.from(availableByPriority.keys()).sort((a, b) => a - b);
let selected: RouteChannelCandidate | null = null;
let selectedPriority = 0;
@@ -829,6 +811,8 @@ export class TokenRouter {
lastUsedAt: nowIso,
cooldownUntil: null,
lastFailAt: null,
consecutiveFailCount: 0,
cooldownLevel: 0,
}).where(eq(schema.routeChannels.id, channelId)).run();
patchCachedChannel(channelId, (channel) => {
@@ -838,6 +822,8 @@ export class TokenRouter {
channel.lastUsedAt = nowIso;
channel.cooldownUntil = null;
channel.lastFailAt = null;
channel.consecutiveFailCount = 0;
channel.cooldownLevel = 0;
});
}
@@ -845,15 +831,42 @@ export class TokenRouter {
* Record failure and set cooldown.
*/
async recordFailure(channelId: number) {
const ch = await db.select().from(schema.routeChannels).where(eq(schema.routeChannels.id, channelId)).get();
if (!ch) return;
const row = await db.select()
.from(schema.routeChannels)
.innerJoin(schema.tokenRoutes, eq(schema.routeChannels.routeId, schema.tokenRoutes.id))
.where(eq(schema.routeChannels.id, channelId))
.get();
if (!row) return;
const ch = row.route_channels;
const route = row.token_routes;
const nowMs = Date.now();
const nowIso = new Date(nowMs).toISOString();
const failCount = (ch.failCount ?? 0) + 1;
const cooldownSec = resolveFailureBackoffSec(failCount);
const cooldownUntil = new Date(Date.now() + cooldownSec * 1000).toISOString();
const nowIso = new Date().toISOString();
const routeStrategy = resolveRouteStrategy(route);
let cooldownUntil: string | null = null;
let consecutiveFailCount = Math.max(0, ch.consecutiveFailCount ?? 0) + 1;
let cooldownLevel = Math.max(0, ch.cooldownLevel ?? 0);
if (routeStrategy === 'round_robin') {
if (consecutiveFailCount >= ROUND_ROBIN_FAILURE_THRESHOLD) {
cooldownLevel = Math.min(cooldownLevel + 1, ROUND_ROBIN_COOLDOWN_LEVELS_SEC.length - 1);
const cooldownSec = resolveRoundRobinCooldownSec(cooldownLevel);
cooldownUntil = cooldownSec > 0 ? new Date(nowMs + cooldownSec * 1000).toISOString() : null;
consecutiveFailCount = 0;
}
} else {
const cooldownSec = resolveFailureBackoffSec(failCount);
cooldownUntil = new Date(nowMs + cooldownSec * 1000).toISOString();
consecutiveFailCount = 0;
cooldownLevel = 0;
}
await db.update(schema.routeChannels).set({
failCount,
lastFailAt: nowIso,
consecutiveFailCount,
cooldownLevel,
cooldownUntil,
}).where(eq(schema.routeChannels.id, channelId)).run();
@@ -861,6 +874,8 @@ export class TokenRouter {
channel.failCount = failCount;
channel.lastFailAt = nowIso;
channel.cooldownUntil = cooldownUntil;
channel.consecutiveFailCount = consecutiveFailCount;
channel.cooldownLevel = cooldownLevel;
});
}
@@ -877,6 +892,94 @@ export class TokenRouter {
// --- Private methods ---
private async selectFromMatch(
match: RouteMatch,
requestedModel: string,
downstreamPolicy: DownstreamRoutingPolicy,
excludeChannelIds: number[] = [],
): Promise<SelectedChannel | null> {
const mappedModel = resolveMappedModel(requestedModel, match.route.modelMapping);
const requestedByDisplayName = isRouteDisplayNameMatch(requestedModel, match.route.displayName);
const bypassSourceModelCheck = requestedByDisplayName;
const routeStrategy = resolveRouteStrategy(match.route);
const nowIso = new Date().toISOString();
const nowMs = Date.now();
const available = match.channels.filter((candidate) => (
this.getCandidateEligibilityReasons(candidate, {
requestedModel,
bypassSourceModelCheck,
excludeChannelIds,
nowIso,
}).length === 0
));
if (available.length === 0) return null;
if (routeStrategy === 'round_robin') {
const selected = this.selectRoundRobinCandidate(available);
if (!selected) return null;
const tokenValue = this.resolveChannelTokenValue(selected);
if (!tokenValue) return null;
await this.recordChannelSelection(selected.channel.id);
const actualModel = resolveActualModelForSelectedChannel(
requestedModel,
match.route,
mappedModel,
selected.channel.sourceModel,
);
return {
...selected,
tokenValue,
tokenName: selected.token?.name || 'default',
actualModel,
};
}
const layers = new Map<number, typeof available>();
for (const candidate of available) {
const priority = candidate.channel.priority ?? 0;
if (!layers.has(priority)) layers.set(priority, []);
layers.get(priority)!.push(candidate);
}
const sortedPriorities = Array.from(layers.keys()).sort((a, b) => a - b);
for (const priority of sortedPriorities) {
const rawLayer = layers.get(priority) ?? [];
const candidates = filterRecentlyFailedCandidates(rawLayer, nowMs);
const selected = this.weightedRandomSelect(
candidates,
requestedByDisplayName
? (candidate) => normalizeChannelSourceModel(candidate.channel.sourceModel) || mappedModel
: mappedModel,
downstreamPolicy,
);
if (!selected) continue;
const tokenValue = this.resolveChannelTokenValue(selected);
if (!tokenValue) continue;
const actualModel = resolveActualModelForSelectedChannel(
requestedModel,
match.route,
mappedModel,
selected.channel.sourceModel,
);
return {
...selected,
tokenValue,
tokenName: selected.token?.name || 'default',
actualModel,
};
}
return null;
}
private async findRoute(model: string, downstreamPolicy: DownstreamRoutingPolicy): Promise<RouteMatch | null> {
let routes = await loadEnabledRoutes();
@@ -973,6 +1076,36 @@ export class TokenRouter {
return reasonParts;
}
private getRoundRobinCandidates(candidates: RouteChannelCandidate[]): RouteChannelCandidate[] {
return [...candidates].sort((left, right) => {
const selectionOrder = compareNullableTimeAsc(
left.channel.lastSelectedAt || left.channel.lastUsedAt,
right.channel.lastSelectedAt || right.channel.lastUsedAt,
);
if (selectionOrder !== 0) return selectionOrder;
const usedOrder = compareNullableTimeAsc(left.channel.lastUsedAt, right.channel.lastUsedAt);
if (usedOrder !== 0) return usedOrder;
return (left.channel.id ?? 0) - (right.channel.id ?? 0);
});
}
private selectRoundRobinCandidate(candidates: RouteChannelCandidate[]): RouteChannelCandidate | null {
return this.getRoundRobinCandidates(candidates)[0] ?? null;
}
private async recordChannelSelection(channelId: number): Promise<void> {
const nowIso = new Date().toISOString();
await db.update(schema.routeChannels).set({
lastSelectedAt: nowIso,
}).where(eq(schema.routeChannels.id, channelId)).run();
patchCachedChannel(channelId, (channel) => {
channel.lastSelectedAt = nowIso;
});
}
private weightedRandomSelect(
candidates: RouteChannelCandidate[],
modelName: string | ((candidate: RouteChannelCandidate) => string),
src/web/pages/Models.marketplace-text.test.tsx
+130
View File
@@ -190,4 +190,134 @@ describe('Models marketplace text', () => {
root?.unmount();
}
});
it('limits expanded account and pricing detail to the selected site filter', async () => {
apiMock.getModelsMarketplace.mockResolvedValue({
models: [
{
name: 'gpt-4o',
accountCount: 2,
tokenCount: 3,
avgLatency: 500,
successRate: 96,
description: 'demo model',
tags: ['chat'],
supportedEndpointTypes: ['openai'],
pricingSources: [
{
siteId: 1,
siteName: '站点 A',
accountId: 1,
username: 'user-a',
ownerBy: null,
enableGroups: [],
groupPricing: {
default: {
quotaType: 0,
inputPerMillion: 1,
outputPerMillion: 2,
},
},
},
{
siteId: 2,
siteName: '站点 B',
accountId: 2,
username: 'user-b',
ownerBy: null,
enableGroups: [],
groupPricing: {
default: {
quotaType: 0,
inputPerMillion: 3,
outputPerMillion: 4,
},
},
},
],
accounts: [
{
id: 1,
site: '站点 A',
username: 'user-a',
latency: 320,
balance: 12.5,
tokens: [
{ id: 1, name: 'token-a-1', isDefault: true },
{ id: 2, name: 'token-a-2', isDefault: false },
],
},
{
id: 2,
site: '站点 B',
username: 'user-b',
latency: 680,
balance: 8.4,
tokens: [
{ id: 3, name: 'token-b-1', isDefault: true },
],
},
],
},
],
});
let root: ReturnType<typeof create> | null = null;
try {
await act(async () => {
root = create(
<MemoryRouter initialEntries={['/models']}>
<ToastProvider>
<Models />
</ToastProvider>
</MemoryRouter>,
);
});
await flushMicrotasks();
const siteFilterItem = root!.root.find((node) => (
node.type === 'div'
&& typeof node.props.className === 'string'
&& node.props.className.includes('filter-item')
&& typeof node.props.onClick === 'function'
&& collectText(node).includes('站点 A')
));
await act(async () => {
siteFilterItem.props.onClick();
});
await flushMicrotasks();
const cards = root!.root.findAll((node) => (
node.type === 'div'
&& typeof node.props.className === 'string'
&& node.props.className.includes('model-card')
&& typeof node.props.onClick === 'function'
));
expect(cards.length).toBeGreaterThan(0);
await act(async () => {
cards[0]!.props.onClick();
});
await flushMicrotasks();
const expandedSections = root!.root.findAll((node) => (
node.type === 'div'
&& typeof node.props.className === 'string'
&& node.props.className.includes('model-card-expand')
));
expect(expandedSections.length).toBe(1);
const expandedText = collectText(expandedSections[0]!);
expect(expandedText).toContain('站点 A');
expect(expandedText).toContain('user-a');
expect(expandedText).toContain('token-a-1');
expect(expandedText).not.toContain('站点 B');
expect(expandedText).not.toContain('user-b');
expect(expandedText).not.toContain('token-b-1');
} finally {
root?.unmount();
}
});
});
src/web/pages/Models.tsx
+29 -7
View File
@@ -292,26 +292,50 @@ export default function Models() {
});
}, [data.models, search, activeSite, activeBrand, sortBy, sortDir]);
// Keep expanded detail consistent with filters (especially site filter).
// The list-level filter uses "model has at least one account on this site" semantics;
// once a model is shown, its detail should honor the active site as well.
const detailModels = useMemo(() => {
if (!activeSite) return filteredModels;
return filteredModels.map((model) => {
const accounts = model.accounts.filter((account) => account.site === activeSite);
const pricingSources = model.pricingSources.filter((source) => source.siteName === activeSite);
const latencyValues = accounts
.map((account) => account.latency)
.filter((latency): latency is number => typeof latency === 'number' && Number.isFinite(latency));
return {
...model,
accounts,
pricingSources,
accountCount: accounts.length,
tokenCount: accounts.reduce((sum, account) => sum + account.tokens.length, 0),
avgLatency: latencyValues.length > 0
? Math.round(latencyValues.reduce((sum, latency) => sum + latency, 0) / latencyValues.length)
: model.avgLatency,
};
});
}, [filteredModels, activeSite]);
/* ---- pagination ---- */
const totalPages = Math.max(1, Math.ceil(filteredModels.length / pageSize));
const safePageVal = Math.min(page, totalPages);
const paged = filteredModels.slice((safePageVal - 1) * pageSize, safePageVal * pageSize);
const paged = detailModels.slice((safePageVal - 1) * pageSize, safePageVal * pageSize);
useEffect(() => { setPage(1); }, [search, activeSite, activeBrand, pageSize]);
/* ---- stats ---- */
const totalCoverageSlots = filteredModels.reduce((s, m) => s + m.accountCount, 0);
const totalCoverageSlots = detailModels.reduce((s, m) => s + m.accountCount, 0);
const uniqueAccountCount = (() => {
const ids = new Set<number>();
for (const model of filteredModels) {
for (const model of detailModels) {
for (const account of model.accounts) {
ids.add(account.id);
}
}
return ids.size;
})();
const avgLatency = filteredModels.length
? Math.round(filteredModels.reduce((s, m) => s + m.avgLatency, 0) / filteredModels.length)
const avgLatency = detailModels.length
? Math.round(detailModels.reduce((s, m) => s + m.avgLatency, 0) / detailModels.length)
: 0;
/* ---- copy ---- */
@@ -898,5 +922,3 @@ export default function Models() {
</div>
);
}
src/web/pages/TokenRoutes.tsx
+37
View File
@@ -28,6 +28,7 @@ import type {
RouteSortDir,
GroupFilter,
RouteSummaryRow,
RouteRoutingStrategy,
RouteDecision,
RouteIconOption,
MissingTokenRouteSiteActionItem,
@@ -88,6 +89,7 @@ export default function TokenRoutes() {
const [channelTokenDraft, setChannelTokenDraft] = useState<Record<number, number>>({});
const [updatingChannel, setUpdatingChannel] = useState<Record<number, boolean>>({});
const [savingPriorityByRoute, setSavingPriorityByRoute] = useState<Record<number, boolean>>({});
const [updatingRoutingStrategyByRoute, setUpdatingRoutingStrategyByRoute] = useState<Record<number, boolean>>({});
const [decisionByRoute, setDecisionByRoute] = useState<Record<number, RouteDecision | null>>({});
const [loadingDecision, setLoadingDecision] = useState(false);
@@ -349,6 +351,32 @@ export default function TokenRoutes() {
}
};
const handleRoutingStrategyChange = async (route: RouteSummaryRow, routingStrategy: RouteRoutingStrategy) => {
const currentStrategy = route.routingStrategy === 'round_robin' ? 'round_robin' : 'weighted';
if (routingStrategy === currentStrategy) return;
setUpdatingRoutingStrategyByRoute((prev) => ({ ...prev, [route.id]: true }));
setRouteSummaries((prev) => prev.map((item) => (
item.id === route.id
? { ...item, routingStrategy }
: item
)));
try {
await api.updateRoute(route.id, { routingStrategy });
toast.success(routingStrategy === 'round_robin' ? '已切换为轮询策略' : '已切换为权重随机策略');
await load();
} catch (e: any) {
setRouteSummaries((prev) => prev.map((item) => (
item.id === route.id
? { ...item, routingStrategy: currentStrategy }
: item
)));
toast.error(e.message || '更新路由策略失败');
} finally {
setUpdatingRoutingStrategyByRoute((prev) => ({ ...prev, [route.id]: false }));
}
};
// Stable derived value: only changes when route patterns change (not on enabled toggle)
const routePatterns = useMemo(
() => routeSummaries.map((r) => ({ id: r.id, modelPattern: r.modelPattern })),
@@ -761,6 +789,12 @@ export default function TokenRoutes() {
const handleToggleEnabledRef = useRef(handleToggleRouteEnabled);
handleToggleEnabledRef.current = handleToggleRouteEnabled;
const stableToggleEnabled = useCallback((route: RouteSummaryRow) => { handleToggleEnabledRef.current(route); }, []);
const handleRoutingStrategyChangeRef = useRef(handleRoutingStrategyChange);
handleRoutingStrategyChangeRef.current = handleRoutingStrategyChange;
const stableRoutingStrategyChange = useCallback(
(route: RouteSummaryRow, strategy: RouteRoutingStrategy) => handleRoutingStrategyChangeRef.current(route, strategy),
[],
);
const stableTokenDraftChange = useCallback(
(channelId: number, tokenId: number) => setChannelTokenDraft((prev) => ({ ...prev, [channelId]: tokenId })),
[],
@@ -995,6 +1029,7 @@ export default function TokenRoutes() {
>
<MobileField label="模型" value={route.modelPattern} />
<MobileField label="通道" value={route.channelCount} />
<MobileField label="策略" value={route.routingStrategy === 'round_robin' ? tr('轮询') : tr('权重随机')} />
<MobileField label="状态" value={route.enabled ? tr('启用') : tr('禁用')} />
<div className="mobile-card-actions">
<button
@@ -1019,6 +1054,8 @@ export default function TokenRoutes() {
onEdit={stableEditRoute}
onDelete={stableDeleteRoute}
onToggleEnabled={stableToggleEnabled}
onRoutingStrategyChange={stableRoutingStrategyChange}
updatingRoutingStrategy={!!updatingRoutingStrategyByRoute[route.id]}
channels={channelsByRouteId[route.id]}
loadingChannels={!!loadingChannelsByRouteId[route.id]}
routeDecision={decisionByRoute[route.id] || null}
src/web/pages/token-routes/AddChannelModal.tsx
+21 -7
View File
@@ -6,6 +6,11 @@ import { useToast } from '../../components/Toast.js';
import { tr } from '../../i18n.js';
import type { RouteCandidateView, RouteAccountOption, RouteTokenOption } from '../helpers/routeModelCandidatesIndex.js';
import type { RouteMissingTokenHint } from '../helpers/routeMissingTokenHints.js';
import {
buildFixedTokenOptionDescription,
buildFixedTokenOptionLabel,
describeTokenBinding,
} from './tokenBindingPresentation.js';
type ChannelSelection = {
accountId: number;
@@ -79,13 +84,10 @@ export default function AddChannelModal({
return next;
}
const tokens = candidateView.tokenOptionsByAccountId[account.id] || [];
const defaultToken = tokens.find((t) => t.isDefault) || tokens[0] || null;
return {
...prev,
[account.id]: {
accountId: account.id,
tokenId: defaultToken?.id,
sourceModel: defaultToken?.sourceModel,
},
};
});
@@ -191,6 +193,7 @@ export default function AddChannelModal({
const tokens = candidateView.tokenOptionsByAccountId[account.id] || [];
const selection = selectedAccounts[account.id];
const isExisting = existingChannelAccountIds?.has(account.id);
const tokenBinding = describeTokenBinding(tokens, selection?.tokenId || 0);
return (
<div
@@ -219,7 +222,7 @@ export default function AddChannelModal({
{isSelected && tokens.length > 0 && (
<div style={{ marginTop: 6, paddingLeft: 24 }} onClick={(e) => e.stopPropagation()}>
<div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginBottom: 4 }}>{tr('令牌')}:</div>
<div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginBottom: 4 }}>{tr('令牌绑定')}:</div>
<ModernSelect
size="sm"
value={(() => {
@@ -235,14 +238,25 @@ export default function AddChannelModal({
updateTokenForAccount(account.id, Number.parseInt(tokenRaw, 10) || 0, sourceParts.join('::'));
}}
options={[
{ value: '0', label: tr('默认令牌') },
{
value: '0',
label: tr('跟随账号默认'),
description: tokenBinding.followOptionDescription,
},
...tokens.map((token: RouteTokenOption) => ({
value: `${token.id}::${token.sourceModel || ''}`,
label: `${token.name}${token.isDefault ? '（默认）' : ''}${token.sourceModel ? ` [${token.sourceModel}]` : ''}`,
label: buildFixedTokenOptionLabel(token, {
includeDefaultTag: true,
includeSourceModel: true,
}),
description: buildFixedTokenOptionDescription(token),
})),
]}
placeholder={tr('选择令牌')}
placeholder={tr('选择绑定方式')}
/>
<div style={{ marginTop: 4, fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.4 }}>
{tokenBinding.helperText}
</div>
</div>
)}
</div>
src/web/pages/token-routes/RouteCard.tsx
+47 -1
View File
@@ -14,9 +14,17 @@ import {
sortableKeyboardCoordinates,
} from '@dnd-kit/sortable';
import { BrandGlyph, InlineBrandIcon, type BrandInfo } from '../../components/BrandIcon.js';
import ModernSelect from '../../components/ModernSelect.js';
import { useAnimatedVisibility } from '../../components/useAnimatedVisibility.js';
import { tr } from '../../i18n.js';
import type { RouteSummaryRow, RouteChannel, RouteDecision, RouteDecisionCandidate, MissingTokenRouteSiteActionItem } from './types.js';
import type {
RouteSummaryRow,
RouteChannel,
RouteDecision,
RouteDecisionCandidate,
MissingTokenRouteSiteActionItem,
RouteRoutingStrategy,
} from './types.js';
import type { RouteCandidateView, RouteTokenOption } from '../helpers/routeModelCandidatesIndex.js';
import { SortableChannelRow } from './SortableChannelRow.js';
import {
@@ -34,6 +42,8 @@ type RouteCardProps = {
onEdit: (route: RouteSummaryRow) => void;
onDelete: (routeId: number) => void;
onToggleEnabled: (route: RouteSummaryRow) => void;
onRoutingStrategyChange: (route: RouteSummaryRow, strategy: RouteRoutingStrategy) => void;
updatingRoutingStrategy: boolean;
// Channel data (loaded on demand)
channels: RouteChannel[] | undefined;
loadingChannels: boolean;
@@ -79,6 +89,8 @@ function RouteCardInner({
onEdit,
onDelete,
onToggleEnabled,
onRoutingStrategyChange,
updatingRoutingStrategy,
channels,
loadingChannels,
routeDecision,
@@ -100,6 +112,19 @@ function RouteCardInner({
const routeIcon = resolveRouteIcon(route);
const exactRoute = isExactModelPattern(route.modelPattern);
const title = resolveRouteTitle(route);
const routingStrategy = route.routingStrategy === 'round_robin' ? 'round_robin' : 'weighted';
const routingStrategyOptions = [
{
value: 'weighted',
label: tr('权重随机'),
description: tr('按优先级、权重和成本信号综合选择'),
},
{
value: 'round_robin',
label: tr('轮询'),
description: tr('按全局顺序轮流调用，忽略优先级，连续失败 3 次后进入分级冷却'),
},
] as const;
const sensors = useSensors(
useSensor(PointerSensor, { activationConstraint: { distance: 4 } }),
@@ -172,6 +197,10 @@ function RouteCardInner({
{route.channelCount} {tr('通道')}
</span>
<span className="badge badge-muted" style={{ fontSize: 10, flexShrink: 0 }}>
{routingStrategy === 'round_robin' ? tr('轮询') : tr('权重随机')}
</span>
<svg
width="14" height="14" viewBox="0 0 20 20" fill="none" stroke="currentColor" strokeWidth="2"
style={{ flexShrink: 0, color: 'var(--color-text-muted)' }}
@@ -251,6 +280,23 @@ function RouteCardInner({
</div>
)}
<div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12, marginBottom: 12, flexWrap: 'wrap' }}>
<div style={{ fontSize: 12, color: 'var(--color-text-secondary)' }}>
{tr('路由策略')}
</div>
<div style={{ minWidth: 220, maxWidth: 320, flex: '1 1 220px' }}>
<ModernSelect
size="sm"
value={routingStrategy}
disabled={updatingRoutingStrategy}
onChange={(nextValue) => onRoutingStrategyChange(route, nextValue as RouteRoutingStrategy)}
options={routingStrategyOptions.map((option) => ({ ...option }))}
placeholder={tr('选择路由策略')}
emptyLabel={tr('暂无可选策略')}
/>
</div>
</div>
{/* Missing token hints + Add channel button */}
<div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8, marginBottom: 10, flexWrap: 'wrap' }}>
{missingTokenSiteItems.length > 0 ? (
src/web/pages/token-routes/SortableChannelRow.tsx
+40 -8
View File
@@ -3,6 +3,11 @@ import { useSortable } from '@dnd-kit/sortable';
import { CSS } from '@dnd-kit/utilities';
import ModernSelect from '../../components/ModernSelect.js';
import type { SortableChannelRowProps } from './types.js';
import {
buildFixedTokenOptionDescription,
buildFixedTokenOptionLabel,
describeTokenBinding,
} from './tokenBindingPresentation.js';
import { getChannelDecisionState, getPriorityTagStyle, getProbabilityColor } from './utils.js';
export function SortableChannelRow({
@@ -48,6 +53,7 @@ export function SortableChannelRow({
};
const decisionState = getChannelDecisionState(decisionCandidate, channel, isExactRoute, loadingDecision);
const tokenBinding = describeTokenBinding(tokenOptions, activeTokenId, channel.token?.name ?? null);
return (
<div ref={setNodeRef} style={rowStyle}>
@@ -105,11 +111,29 @@ export function SortableChannelRow({
className="badge"
style={{
fontSize: 10,
background: 'color-mix(in srgb, var(--color-info) 15%, transparent)',
color: 'var(--color-info)',
background: tokenBinding.isFollowingAccountDefault
? 'color-mix(in srgb, var(--color-info) 15%, transparent)'
: 'color-mix(in srgb, var(--color-warning) 15%, transparent)',
color: tokenBinding.isFollowingAccountDefault ? 'var(--color-info)' : 'var(--color-warning)',
}}
>
{channel.token?.name || '默认令牌'}
{tokenBinding.bindingModeLabel}
</span>
<span
className="badge"
style={{
fontSize: 10,
background: 'color-mix(in srgb, var(--color-primary) 10%, transparent)',
color: 'var(--color-primary)',
maxWidth: 220,
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
}}
data-tooltip={`当前生效：${tokenBinding.effectiveTokenName}`}
>
当前生效：{tokenBinding.effectiveTokenName}
</span>
{channel.sourceModel ? (
@@ -174,28 +198,36 @@ export function SortableChannelRow({
</div>
<div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
<div style={{ minWidth: 150, flex: 1 }}>
<div style={{ minWidth: 220, flex: 1 }}>
<ModernSelect
size="sm"
value={String(activeTokenId || 0)}
onChange={(nextValue) => onTokenDraftChange(channel.id, Number.parseInt(nextValue, 10) || 0)}
disabled={isUpdatingToken}
options={[
{ value: '0', label: '默认令牌' },
{
value: '0',
label: '跟随账号默认',
description: tokenBinding.followOptionDescription,
},
...tokenOptions.map((token) => ({
value: String(token.id),
label: `${token.name}${token.isDefault ? '（默认）' : ''}`,
label: buildFixedTokenOptionLabel(token, { includeDefaultTag: true }),
description: buildFixedTokenOptionDescription(token),
})),
]}
placeholder="默认令牌"
placeholder="选择令牌绑定方式"
/>
<div style={{ marginTop: 4, fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.4 }}>
{tokenBinding.helperText}
</div>
</div>
<button
onClick={onSaveToken}
disabled={isUpdatingToken}
className="btn btn-link btn-link-info"
>
{isUpdatingToken ? <span className="spinner spinner-sm" /> : '改令牌'}
{isUpdatingToken ? <span className="spinner spinner-sm" /> : '保存'}
</button>
</div>
src/web/pages/token-routes/tokenBindingPresentation.test.ts
+47
View File
@@ -0,0 +1,47 @@
import { describe, expect, it } from 'vitest';
import {
buildFixedTokenOptionDescription,
buildFixedTokenOptionLabel,
describeTokenBinding,
} from './tokenBindingPresentation.js';
describe('tokenBindingPresentation', () => {
it('describes follow-account-default mode with the current default token', () => {
const result = describeTokenBinding([
{ id: 1, name: 'token-a', isDefault: true },
{ id: 2, name: 'token-b', isDefault: false },
], 0);
expect(result.bindingModeLabel).toBe('跟随账号默认');
expect(result.effectiveTokenName).toBe('token-a');
expect(result.helperText).toContain('以后账号默认变化时会自动切换');
expect(result.followOptionDescription).toContain('当前生效：token-a');
});
it('describes fixed mode when the selected token is also the account default', () => {
const result = describeTokenBinding([
{ id: 1, name: 'default', isDefault: true },
{ id: 2, name: 'backup', isDefault: false },
], 1);
expect(result.bindingModeLabel).toBe('固定令牌');
expect(result.effectiveTokenName).toBe('default');
expect(result.helperText).toContain('它目前也是账号默认');
expect(result.helperText).toContain('不会跟着变');
});
it('formats fixed token options with clearer labels and descriptions', () => {
const token = {
id: 3,
name: 'shared-token',
isDefault: true,
sourceModel: 'gpt-4o-mini',
};
expect(buildFixedTokenOptionLabel(token, {
includeDefaultTag: true,
includeSourceModel: true,
})).toBe('固定使用：shared-token（当前账号默认） [gpt-4o-mini]');
expect(buildFixedTokenOptionDescription(token)).toContain('以后不会自动跟随');
});
});
src/web/pages/token-routes/tokenBindingPresentation.ts
+80
View File
@@ -0,0 +1,80 @@
export type TokenBindingOption = {
id: number;
name: string;
isDefault: boolean;
sourceModel?: string;
};
export type TokenBindingPresentation = {
isFollowingAccountDefault: boolean;
bindingModeLabel: string;
effectiveTokenName: string;
helperText: string;
followOptionDescription: string;
};
export function getDefaultTokenOption(options: TokenBindingOption[]): TokenBindingOption | null {
return options.find((option) => option.isDefault) || null;
}
export function describeTokenBinding(
options: TokenBindingOption[],
activeTokenId: number,
fallbackTokenName?: string | null,
): TokenBindingPresentation {
const defaultToken = getDefaultTokenOption(options);
const selectedToken = activeTokenId
? options.find((option) => option.id === activeTokenId) || null
: null;
if (!activeTokenId) {
const effectiveTokenName = defaultToken?.name || fallbackTokenName || '未设置默认令牌';
return {
isFollowingAccountDefault: true,
bindingModeLabel: '跟随账号默认',
effectiveTokenName,
helperText: defaultToken
? `跟随账号默认。当前生效的是「${defaultToken.name}」，以后账号默认变化时会自动切换。`
: '跟随账号默认。当前账号还没有默认令牌。',
followOptionDescription: defaultToken
? `当前生效：${defaultToken.name}；以后账号默认变化时会自动切换`
: '以后账号默认变化时会自动切换',
};
}
const effectiveTokenName = selectedToken?.name || fallbackTokenName || `token-${activeTokenId}`;
return {
isFollowingAccountDefault: false,
bindingModeLabel: '固定令牌',
effectiveTokenName,
helperText: selectedToken?.isDefault
? `已固定到「${effectiveTokenName}」。它目前也是账号默认，但以后账号默认变化时，这个通道不会跟着变。`
: `已固定到「${effectiveTokenName}」，不会随账号默认变化。`,
followOptionDescription: defaultToken
? `当前生效：${defaultToken.name}；以后账号默认变化时会自动切换`
: '以后账号默认变化时会自动切换',
};
}
export function buildFixedTokenOptionLabel(
token: TokenBindingOption,
options: {
includeDefaultTag?: boolean;
includeSourceModel?: boolean;
} = {},
): string {
let label = `固定使用：${token.name}`;
if (options.includeDefaultTag && token.isDefault) {
label += '（当前账号默认）';
}
if (options.includeSourceModel && token.sourceModel) {
label += ` [${token.sourceModel}]`;
}
return label;
}
export function buildFixedTokenOptionDescription(token: TokenBindingOption): string {
return token.isDefault
? '固定到这条令牌；它目前也是账号默认，但以后不会自动跟随'
: '固定到这条令牌；不随账号默认变化';
}
src/web/pages/token-routes/types.ts
+3
View File
@@ -4,6 +4,7 @@ import type { BrandInfo } from '../../components/BrandIcon.js';
export type RouteSortBy = 'modelPattern' | 'channelCount';
export type RouteSortDir = 'asc' | 'desc';
export type GroupFilter = null | '__all__' | number;
export type RouteRoutingStrategy = 'weighted' | 'round_robin';
export type RouteChannelDraft = {
accountId: number;
@@ -46,6 +47,7 @@ export type RouteRow = {
displayName?: string | null;
displayIcon?: string | null;
modelMapping?: string | null;
routingStrategy?: RouteRoutingStrategy | null;
decisionSnapshot?: RouteDecision | null;
decisionRefreshedAt?: string | null;
enabled: boolean;
@@ -58,6 +60,7 @@ export type RouteSummaryRow = {
displayName: string | null;
displayIcon: string | null;
modelMapping: string | null;
routingStrategy?: RouteRoutingStrategy | null;
enabled: boolean;
channelCount: number;
enabledChannelCount: number;