Support wildcard/regex model redirects and honor them in provider selection

src/app/v1/_lib/proxy/model-redirector.ts

@@ -2,6 +2,79 @@ import { logger } from "@/lib/logger";
 import type { Provider } from "@/types/provider";
 import type { ProxySession } from "./session";
 
+type RedirectMatchType = "exact" | "wildcard" | "regex";
+
+type ModelRedirectMatch = {
+  redirectedModel: string;
+  matchedPattern: string;
+  matchType: RedirectMatchType;
+};
+
+function parseRegexPattern(pattern: string): RegExp | null {
+  if (!pattern.startsWith("/")) {
+    return null;
+  }
+  const lastSlashIndex = pattern.lastIndexOf("/");
+  if (lastSlashIndex <= 0) {
+    return null;
+  }
+  const body = pattern.slice(1, lastSlashIndex);
+  const flags = pattern.slice(lastSlashIndex + 1);
+  if (!body) {
+    return null;
+  }
+  try {
+    return new RegExp(body, flags);
+  } catch {
+    return null;
+  }
+}
+
+function escapeRegex(input: string): string {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function buildWildcardRegex(pattern: string): RegExp | null {
+  if (!pattern.includes("*")) {
+    return null;
+  }
+  const escaped = escapeRegex(pattern);
+  const wildcard = escaped.replace(/\\\*/g, ".*");
+  return new RegExp(`^${wildcard}$`);
+}
+
+function findRedirectMatch(
+  modelRedirects: Record<string, string>,
+  originalModel: string
+): ModelRedirectMatch | null {
+  const direct = modelRedirects[originalModel];
+  if (direct) {
+    return {
+      redirectedModel: direct,
+      matchedPattern: originalModel,
+      matchType: "exact",
+    };
+  }
+
+  for (const [pattern, redirectedModel] of Object.entries(modelRedirects)) {
+    if (!pattern || pattern === originalModel) {
+      continue;
+    }
+
+    const regexPattern = parseRegexPattern(pattern);
+    if (regexPattern && regexPattern.test(originalModel)) {
+      return { redirectedModel, matchedPattern: pattern, matchType: "regex" };
+    }
+
+    const wildcardRegex = buildWildcardRegex(pattern);
+    if (wildcardRegex && wildcardRegex.test(originalModel)) {
+      return { redirectedModel, matchedPattern: pattern, matchType: "wildcard" };
+    }
+  }
+
+  return null;
+}
+
 /**
  * 模型重定向器
  *
@@ -41,8 +114,8 @@ export class ModelRedirector {
     }
 
     // 检查是否有该模型的重定向配置
-    const redirectedModel = provider.modelRedirects[originalModel];
-    if (!redirectedModel) {
+    const match = findRedirectMatch(provider.modelRedirects, originalModel);
+    if (!match) {
       // 如果新供应商对此模型没有重定向规则，且之前发生过重定向，需要重置
       if (session.isModelRedirected()) {
         ModelRedirector.resetToOriginal(session, originalModel, provider);
@@ -55,11 +128,14 @@ export class ModelRedirector {
       }
       return false;
     }
+    const { redirectedModel, matchedPattern, matchType } = match;
 
     // 执行重定向
     logger.info("[ModelRedirector] Model redirected", {
       originalModel,
       redirectedModel,
+      matchedPattern,
+      matchType,
       providerId: provider.id,
       providerName: provider.name,
       providerType: provider.providerType,
@@ -91,6 +167,8 @@ export class ModelRedirector {
           newPath,
           originalModel,
           redirectedModel,
+          matchedPattern,
+          matchType,
         });
       }
     }
@@ -117,11 +195,15 @@ export class ModelRedirector {
         originalModel: originalModel,
         redirectedModel: redirectedModel,
         billingModel: originalModel, // 始终使用原始模型计费
+        matchedPattern,
+        matchType,
       };
       logger.debug("[ModelRedirector] Added modelRedirect to provider chain", {
         providerId: provider.id,
         originalModel,
         redirectedModel,
+        matchedPattern,
+        matchType,
       });
     }
 
@@ -140,7 +222,8 @@ export class ModelRedirector {
       return originalModel;
     }
 
-    return provider.modelRedirects[originalModel] || originalModel;
+    const match = findRedirectMatch(provider.modelRedirects, originalModel);
+    return match?.redirectedModel || originalModel;
   }
 
   /**
@@ -151,7 +234,10 @@ export class ModelRedirector {
    * @returns 是否配置了重定向
    */
   static hasRedirect(model: string, provider: Provider): boolean {
-    return !!(provider.modelRedirects && model && provider.modelRedirects[model]);
+    if (!provider.modelRedirects || !model) {
+      return false;
+    }
+    return !!findRedirectMatch(provider.modelRedirects, model);
   }
 
   /**

src/app/v1/_lib/proxy/provider-selector.ts

@@ -9,6 +9,7 @@ import { getSystemSettings } from "@/repository/system-config";
 import type { ProviderChainItem } from "@/types/message";
 import type { Provider } from "@/types/provider";
 import type { ClientFormat } from "./format-mapper";
+import { ModelRedirector } from "./model-redirector";
 import { ProxyResponses } from "./responses";
 import type { ProxySession } from "./session";
 
@@ -125,7 +126,10 @@ function providerSupportsModel(provider: Provider, requestedModel: string): bool
         return true;
       }
       // 检查白名单
-      return provider.allowedModels.includes(requestedModel);
+      return (
+        provider.allowedModels.includes(requestedModel) ||
+        ModelRedirector.hasRedirect(requestedModel, provider)
+      );
     }
 
     // 1b. 非 Anthropic 提供商不支持 Claude 模型调度
@@ -137,7 +141,8 @@ function providerSupportsModel(provider: Provider, requestedModel: string): bool
   // 原因：允许 Claude 类型供应商通过 allowedModels/modelRedirects 声明支持非 Claude 模型
   // 场景：Claude 供应商配置模型重定向，将 gemini-* 请求转发到真实的 Gemini 上游
   const explicitlyDeclared = !!(
-    provider.allowedModels?.includes(requestedModel) || provider.modelRedirects?.[requestedModel]
+    provider.allowedModels?.includes(requestedModel) ||
+    ModelRedirector.hasRedirect(requestedModel, provider)
   );
 
   if (explicitlyDeclared) {

src/types/message.ts

@@ -66,6 +66,8 @@ export interface ProviderChainItem {
     originalModel: string; // 用户请求的模型（计费依据）
     redirectedModel: string; // 实际转发的模型
     billingModel: string; // 计费模型（通常等于 originalModel）
+    matchedPattern?: string; // 匹配的重定向模式
+    matchType?: "exact" | "wildcard" | "regex"; // 匹配类型
   };
 
   // 错误信息（记录失败时的上游报错）

tests/unit/proxy/model-redirector-patterns.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "vitest";
+import { ModelRedirector } from "@/app/v1/_lib/proxy/model-redirector";
+import type { Provider } from "@/types/provider";
+
+function buildProvider(modelRedirects: Record<string, string>): Provider {
+  return {
+    id: 1,
+    name: "test-provider",
+    providerType: "claude",
+    isEnabled: true,
+    weight: 1,
+    priority: 0,
+    costMultiplier: 1,
+    groupTag: null,
+    modelRedirects,
+  } as Provider;
+}
+
+describe("ModelRedirector pattern matching", () => {
+  test("matches wildcard patterns", () => {
+    const provider = buildProvider({
+      "gpt-4o-*": "claude-sonnet-4",
+    });
+
+    expect(ModelRedirector.getRedirectedModel("gpt-4o-mini", provider)).toBe("claude-sonnet-4");
+    expect(ModelRedirector.hasRedirect("gpt-4o-mini", provider)).toBe(true);
+  });
+
+  test("matches regex patterns", () => {
+    const provider = buildProvider({
+      "/^gpt-4o-(mini|preview)$/": "claude-sonnet-4",
+    });
+
+    expect(ModelRedirector.getRedirectedModel("gpt-4o-mini", provider)).toBe("claude-sonnet-4");
+    expect(ModelRedirector.getRedirectedModel("gpt-4o-preview", provider)).toBe("claude-sonnet-4");
+    expect(ModelRedirector.hasRedirect("gpt-4o-preview", provider)).toBe(true);
+  });
+
+  test("falls back when regex is invalid", () => {
+    const provider = buildProvider({
+      "/[invalid/": "claude-sonnet-4",
+      "claude-haiku": "claude-sonnet-4",
+    });
+
+    expect(ModelRedirector.getRedirectedModel("claude-haiku", provider)).toBe("claude-sonnet-4");
+    expect(ModelRedirector.hasRedirect("claude-haiku", provider)).toBe(true);
+    expect(ModelRedirector.getRedirectedModel("gpt-4o-mini", provider)).toBe("gpt-4o-mini");
+  });
+});

tests/unit/proxy/provider-selector-model-redirect.test.ts

@@ -47,4 +47,80 @@ describe("ProxyProviderResolver.pickRandomProvider - model redirect", () => {
     expect(context.requestedModel).toBe("claude-test");
     expect(provider?.id).toBe(1);
   });
+
+  test("allows providers with wildcard model redirects for non-claude models", async () => {
+    const { ProxyProviderResolver } = await import("@/app/v1/_lib/proxy/provider-selector");
+
+    vi.spyOn(ProxyProviderResolver as any, "filterByLimits").mockImplementation(
+      async (...args: unknown[]) => args[0] as Provider[]
+    );
+
+    const providers: Provider[] = [
+      {
+        id: 2,
+        name: "p2",
+        isEnabled: true,
+        providerType: "claude",
+        groupTag: null,
+        weight: 1,
+        priority: 0,
+        costMultiplier: 1,
+        allowedModels: [],
+        modelRedirects: {
+          "gpt-4o-*": "claude-sonnet-4",
+        },
+      } as unknown as Provider,
+    ];
+
+    const session = {
+      originalFormat: "claude",
+      authState: null,
+      getProvidersSnapshot: async () => providers,
+      getOriginalModel: () => "gpt-4o-mini",
+      getCurrentModel: () => "gpt-4o-mini",
+      clientRequestsContext1m: () => false,
+    } as any;
+
+    const { provider } = await (ProxyProviderResolver as any).pickRandomProvider(session, []);
+
+    expect(provider?.id).toBe(2);
+  });
+
+  test("allows claude providers with redirect patterns even when allowedModels excludes the model", async () => {
+    const { ProxyProviderResolver } = await import("@/app/v1/_lib/proxy/provider-selector");
+
+    vi.spyOn(ProxyProviderResolver as any, "filterByLimits").mockImplementation(
+      async (...args: unknown[]) => args[0] as Provider[]
+    );
+
+    const providers: Provider[] = [
+      {
+        id: 3,
+        name: "p3",
+        isEnabled: true,
+        providerType: "claude",
+        groupTag: null,
+        weight: 1,
+        priority: 0,
+        costMultiplier: 1,
+        allowedModels: ["claude-legacy"],
+        modelRedirects: {
+          "claude-3-*": "claude-legacy",
+        },
+      } as unknown as Provider,
+    ];
+
+    const session = {
+      originalFormat: "claude",
+      authState: null,
+      getProvidersSnapshot: async () => providers,
+      getOriginalModel: () => "claude-3-haiku",
+      getCurrentModel: () => "claude-3-haiku",
+      clientRequestsContext1m: () => false,
+    } as any;
+
+    const { provider } = await (ProxyProviderResolver as any).pickRandomProvider(session, []);
+
+    expect(provider?.id).toBe(3);
+  });
 });