Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
// API-key model-permission matching: Claude-Code alias/prefix resolution + wildcard/glob pattern
// matching used to decide whether a model is permitted for a key. Pure logic (no DB) extracted from
// db/apiKeys.ts (god-file decomposition); behavior is byte-identical to the original inline defs.
import { getProviderByAlias, resolveProviderId } from "@/shared/constants/providers";
export const CLAUDE_CODE_PROVIDER_PREFIXES = new Set(["cc", "claude"]);
export const CLAUDE_CODE_SHORT_ALIASES = new Set(["sonnet", "opus", "haiku", "fable"]);
export function isTruthyEnvFlag(value: string | undefined): boolean {
return typeof value === "string" && /^(1|true|yes|on)$/i.test(value.trim());
}
export async function preferClaudeCodeForUnprefixedClaudeModels(): Promise<boolean> {
try {
const { getCachedSettings } = await import("../readCache");
const settings = await getCachedSettings();
if (typeof settings.preferClaudeCodeForUnprefixedClaudeModels === "boolean") {
return settings.preferClaudeCodeForUnprefixedClaudeModels;
}
} catch {
// Standalone DB usage may not have the settings cache ready.
}
return isTruthyEnvFlag(process.env.OMNIROUTE_PREFER_CLAUDE_CODE_FOR_UNPREFIXED_CLAUDE_MODELS);
}
export function stripExtendedContextSuffix(modelId: string): string {
return modelId.endsWith("[1m]") ? modelId.slice(0, -4) : modelId;
}
export function isPotentialUnprefixedClaudeCodeModel(modelId: string): boolean {
const clean = stripExtendedContextSuffix(modelId.trim());
return /^claude-/i.test(clean) || CLAUDE_CODE_SHORT_ALIASES.has(clean.toLowerCase());
}
export function addModelCandidate(candidates: Set<string>, modelId: string): void {
const clean = modelId.trim();
if (!clean) return;
candidates.add(clean);
candidates.add(stripExtendedContextSuffix(clean));
}
/**
* Expand provider-scoped model ids with canonical provider id + public alias forms
* (e.g. codex/gpt-5.6-terra ↔ cx/gpt-5.6-terra) so API-key allow/block patterns match
* dashboard restrictions regardless of which prefix the client sends.
*/
export function addProviderAliasScopedCandidates(
candidates: Set<string>,
providerOrAlias: string,
providerScopedModel: string,
resolveProviderId: (aliasOrId: string) => string,
getProviderAlias: (providerId: string) => string
): void {
if (!providerScopedModel) return;
const canonicalId = resolveProviderId(providerOrAlias);
const alias = getProviderAlias(canonicalId);
if (canonicalId !== providerOrAlias) {
addModelCandidate(candidates, `${canonicalId}/${providerScopedModel}`);
}
if (alias !== providerOrAlias && alias !== canonicalId) {
addModelCandidate(candidates, `${alias}/${providerScopedModel}`);
}
}
export function modelPatternMatches(pattern: string, candidates: string[]): boolean {
for (const candidate of candidates) {
if (pattern === candidate) return true;
if (pattern.endsWith("/*")) {
const prefix = pattern.slice(0, -2);
if (!candidate.startsWith(prefix + "/")) continue;
// `provider/*` covers that provider's own models, including ids whose
// model segment itself contains a slash (`cline/deepseek/deepseek-v4-flash`).
// It must not also cover a different provider nested under the same prefix
// (`cline/openrouter/deepseek/deepseek-v4-flash`): that model is served by
// openrouter, which this entry never named.
const rest = candidate.slice(prefix.length + 1);
const nested = rest.indexOf("/");
if (nested > 0 && rest.slice(nested + 1).includes("/")) {
const nextSegment = rest.slice(0, nested);
const nestedProvider = getProviderByAlias(nextSegment);
// `<gateway>/<other-provider>/<model>` is another provider's model
// reached through this gateway (`cline/openrouter/deepseek/deepseek-v4-flash`).
// `<gateway>/<family>/<model>` is still this gateway's own model even
// when the family name is also a provider (`cline/deepseek/deepseek-v4-flash`).
const namedProvider = resolveProviderId(prefix.split("/")[0]);
if (nestedProvider && nestedProvider.id !== namedProvider) continue;
}
return true;
}
if (pattern.includes("*") && matchesWildcardPattern(pattern, candidate)) {
return true;
}
}
return false;
}
export function hasClaudeCodeWildcardPermission(
allowedModels: string[] | undefined,
candidates: string[]
): boolean {
if (!allowedModels || allowedModels.length === 0) return false;
return allowedModels.some(
(pattern) =>
(pattern === "cc/*" || pattern === "claude/*") &&
candidates.some((candidate) => modelPatternMatches(pattern, [candidate]))
);
}
/**
* Match an API-key wildcard scope pattern against a model id without
* compiling a RegExp from string concatenation (avoid ReDoS exposure on
* operator-supplied patterns and silence the Semgrep `js/regex-injection`
* advisory for `new RegExp(<dynamic>)`).
*
* Supported pattern syntax (only what real scopes use):
* - literal segments
* - `*` matches any run of characters, but does NOT cross `/`
*
* Walks the pattern token-by-token: each `*` consumes the longest possible
* run within the current path segment, then the next literal anchor must
* appear before the segment boundary. Worst-case complexity is O(n*m)
* where n = pattern length, m = candidate length — there is no nested
* backtracking that could explode adversarially.
*/
export function matchesWildcardPattern(pattern: string, candidate: string): boolean {
const pSegs = pattern.split("/");
const cSegs = candidate.split("/");
if (pSegs.length !== cSegs.length) return false;
for (let i = 0; i < pSegs.length; i++) {
if (!segmentMatchesWildcard(pSegs[i], cSegs[i])) return false;
}
return true;
}
export function segmentMatchesWildcard(pattern: string, segment: string): boolean {
if (pattern === segment) return true;
if (!pattern.includes("*")) return false;
const parts = pattern.split("*");
// Anchor first literal to the start.
let cursor = 0;
const first = parts[0];
if (first) {
if (!segment.startsWith(first)) return false;
cursor = first.length;
}
// Anchor last literal to the end.
const last = parts[parts.length - 1];
const endLimit = segment.length - last.length;
if (last) {
if (!segment.endsWith(last)) return false;
}
// Each middle literal must appear in order between cursor and endLimit.
for (let i = 1; i < parts.length - 1; i++) {
const piece = parts[i];
if (!piece) continue;
const idx = segment.indexOf(piece, cursor);
if (idx === -1 || idx + piece.length > endLimit) return false;
cursor = idx + piece.length;
}
return cursor <= endLimit;
}