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
/**
* db/featureFlags.ts — Feature flag DB overrides.
*
* Stores per-flag override values in the key_value table under the
* "feature_flags" namespace. When an override is present it takes precedence
* over the process environment variable of the same name.
*/
import { FEATURE_FLAG_DEFINITIONS } from "@/shared/constants/featureFlagDefinitions";
import { getDbInstance } from "./core";
import { finishModelCatalogWriteWithoutBackup } from "./models/modelCatalogWriteSignals";
const NAMESPACE = "feature_flags";
// Flag reads sit on hot paths that call them once per string leaf of a request
// body (sanitizePII, the PII masker guardrail), so a synchronous SELECT per
// read turned a 2 MB agentic request into a thousand SQLite round trips. The
// cache is invalidated by every writer in this module; the short TTL only
// covers edits made to the store from outside this process. It is keyed by the
// database instance so a reopened store (tests, resetDbInstance) starts clean.
const OVERRIDE_CACHE_TTL_MS = 1000;
type OverrideCacheEntry = { value: string | undefined; expiresAt: number };
const overrideCaches = new WeakMap<object, Map<string, OverrideCacheEntry>>();
function overrideCacheFor(db: object): Map<string, OverrideCacheEntry> {
let cache = overrideCaches.get(db);
if (!cache) {
cache = new Map();
overrideCaches.set(db, cache);
}
return cache;
}
export function clearFeatureFlagOverrideCache(key?: string): void {
const cache = overrideCaches.get(getDbInstance());
if (!cache) return;
if (key === undefined) cache.clear();
else cache.delete(key);
}
const CATALOG_RELEVANT_FEATURE_FLAGS = new Set([
"MODEL_CATALOG_INCLUDE_NAMES",
"MODELS_CATALOG_PREFIX_MODE",
"EXPOSE_CC_DISCOVERY_ALIASES",
"NO_THINKING_ALIAS_ENABLED",
"OMNIROUTE_DISABLE_THINKING_LEVEL_VARIANTS",
"CATALOG_MIRROR_REFINEMENTS_ENABLED",
// #16929: hides models with no runnable endpoint adapter from /v1/models.
"MODEL_ENDPOINT_CAPABILITY_GATE_ENABLED",
"MODELS_DEV_EFFORT_TIERS_ENABLED",
]);
/**
* Returns all feature flag overrides as a key→value map.
*/
export function getFeatureFlagOverrides(): Record<string, string> {
const db = getDbInstance();
const rows = db
.prepare("SELECT key, value FROM key_value WHERE namespace = ?")
.all(NAMESPACE) as Array<{ key: string; value: string }>;
const result: Record<string, string> = {};
for (const row of rows) {
result[row.key] = row.value;
}
return result;
}
/**
* Returns the override value for a single flag, or undefined if no override
* is stored.
*/
export function getFeatureFlagOverride(key: string): string | undefined {
const db = getDbInstance();
const cache = overrideCacheFor(db);
const now = Date.now();
const cached = cache.get(key);
if (cached && cached.expiresAt > now) return cached.value;
const row = db
.prepare("SELECT value FROM key_value WHERE namespace = ? AND key = ?")
.get(NAMESPACE, key) as { value: string } | undefined;
cache.set(key, { value: row?.value, expiresAt: now + OVERRIDE_CACHE_TTL_MS });
return row?.value;
}
/**
* Persists (or replaces) an override for a single flag.
*/
export function setFeatureFlagOverride(key: string, value: string): void {
const definition = FEATURE_FLAG_DEFINITIONS.find((d) => d.key === key);
if (!definition) {
throw new Error(`Unknown feature flag key: ${key}`);
}
if (
definition.type === "enum" &&
definition.enumValues &&
!definition.enumValues.includes(value)
) {
throw new Error(
`Invalid value "${value}" for enum flag ${key}. Allowed: ${definition.enumValues.join(", ")}`
);
}
const db = getDbInstance();
db.prepare("INSERT OR REPLACE INTO key_value (namespace, key, value) VALUES (?, ?, ?)").run(
NAMESPACE,
key,
value
);
clearFeatureFlagOverrideCache(key);
if (CATALOG_RELEVANT_FEATURE_FLAGS.has(key)) {
finishModelCatalogWriteWithoutBackup();
}
}
/**
* Removes the override for a single flag, restoring env-var / default
* behaviour.
*/
export function removeFeatureFlagOverride(key: string): void {
const db = getDbInstance();
db.prepare("DELETE FROM key_value WHERE namespace = ? AND key = ?").run(NAMESPACE, key);
clearFeatureFlagOverrideCache(key);
if (CATALOG_RELEVANT_FEATURE_FLAGS.has(key)) {
finishModelCatalogWriteWithoutBackup();
}
}
/**
* Removes all stored feature flag overrides.
*/
export function clearAllFeatureFlagOverrides(): void {
const db = getDbInstance();
// Placeholders are derived from the set size — a hardcoded `IN (?, ?, ?)` breaks
// (parameter-count mismatch) the moment a flag is added to the set above.
const catalogFlags = Array.from(CATALOG_RELEVANT_FEATURE_FLAGS);
const placeholders = catalogFlags.map(() => "?").join(", ");
const hadRelevantOverride = Boolean(
db
.prepare(`SELECT 1 FROM key_value WHERE namespace = ? AND key IN (${placeholders}) LIMIT 1`)
.get(NAMESPACE, ...catalogFlags)
);
db.prepare("DELETE FROM key_value WHERE namespace = ?").run(NAMESPACE);
clearFeatureFlagOverrideCache();
if (hadRelevantOverride) {
finishModelCatalogWriteWithoutBackup();
}
}