Skip to content

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

6.1 KB
Raw Blame
/**
 * Pure catalog → Model Override target conversion.
 *
 * The operator-facing Model Overrides surface must present a compatible
 * provider node under its configured public `prefix` (e.g. `vibeproxy/gpt-4o`)
 * — never the generated `openai-compatible-chat-<uuid>` node id (#9557).
 *
 * The pricing catalog keeps the internal `id` (the DB node id, which PricingTab
 * uses to key pricing data) and, when the node has a configured prefix, also
 * carries `displayPrefix`. This helper prefers `displayPrefix` for the public
 * label/target while leaving the raw id untouched for storage/runtime lookup.
 *
 * Model-Overrides eligibility seam: a compatible provider node is eligible only
 * when it is the unique, non-reserved runtime-routable winner of its configured
 * prefix. The catalog marks such winners with `modelOverrideEligible === true`
 * (and a `displayPrefix`); reserved/losing/no-public-prefix compatible nodes are
 * marked `modelOverrideEligible === false` and are SKIPPED — never surfaced
 * under a generated node UUID. Built-in / no-compatible catalog entries carry no
 * flag and remain targetable.
 */

export interface PricingCatalogModel {
  id: string;
  name: string;
}

export interface PricingCatalogProvider {
  id: string;
  alias: string;
  displayPrefix?: string;
  /** Explicit Model-Overrides eligibility; undefined ⇒ eligible (built-in/no-compatible). */
  modelOverrideEligible?: boolean;
  models: PricingCatalogModel[];
}

export interface ModelOverrideTarget {
  target: string;
  provider: string;
  modelId: string;
  label: string;
}

/**
 * Whether a catalog provider is targetable in Model Overrides. Only compatible
 * nodes marked ineligible (reserved/losing/no-public-prefix) are skipped; all
 * built-in and no-compatible entries are eligible.
 */
export function isModelOverrideEligible(provider: PricingCatalogProvider): boolean {
  return provider.modelOverrideEligible !== false;
}

/**
 * Public display prefix for a compatible provider node, falling back to its
 * internal id when no operator-configured prefix is set.
 */
export function modelOverrideProviderPrefix(provider: PricingCatalogProvider): string {
  return provider.displayPrefix?.trim() || provider.id;
}

/**
 * Convert the /api/pricing/models catalog into Model Override targets. Each
 * target uses the node's public prefix (when configured) so the selector,
 * search, selected model, and the target sent to the override API never expose
 * a generated node UUID. Ineligible compatible nodes are skipped entirely.
 */
import { normalizeForSearch } from "@/shared/utils/turkishText";

export function toModelOverrideTargets(
  catalog: Record<string, PricingCatalogProvider>
): ModelOverrideTarget[] {
  return Object.values(catalog).flatMap((provider) => {
    if (!isModelOverrideEligible(provider)) return [];
    const prefix = modelOverrideProviderPrefix(provider);
    return provider.models.map((model) => ({
      target: `${prefix}/${model.id}`,
      provider: prefix,
      modelId: model.id,
      label: `${prefix}/${model.id}`,
    }));
  });
}

/** Window for the default (unfiltered) picker view. Unchanged UX. */
const DEFAULT_MODEL_OVERRIDE_TARGET_WINDOW = 80;

/**
 * Window for a filtered view. Wide enough that a matched provider's full model
 * list can never be crowded out of the window by sibling providers whose names
 * merely share a substring (413 providers / 12.8k+ targets today; `bai` alone
 * renders 58 rows).
 */
const FILTERED_MODEL_OVERRIDE_TARGET_WINDOW = 300;

/**
 * Relevance tiers for a query match; higher sorts first.
 *
 * The picker's search is a plain substring match across provider/model/label,
 * so a short query like `bai` also matches `baichuan`, `bailian-coding-plan`,
 * `baidu`, and `bailing` — and the old fixed `slice(0, 80)` cut in catalog
 * order, hiding the intended provider (provider #233 of 413) behind its
 * alphabetically-lucky neighbors. Scoring encodes operator intent:
 * exact provider match > provider-scoped form (`bai/`) > provider prefix >
 * model-id prefix > plain substring.
 */
function scoreModelOverrideTarget(target: ModelOverrideTarget, query: string): number {
  const provider = normalizeForSearch(target.provider);
  const modelId = normalizeForSearch(target.modelId);
  const label = normalizeForSearch(target.label);
  const targetText = normalizeForSearch(target.target);

  // Parity with the previous filter: same four fields, same substring
  // semantics. `label` and `target` are identical for the current producer
  // but the field parity is the contract, not an implementation detail.
  if (!(
    provider.includes(query) ||
    modelId.includes(query) ||
    label.includes(query) ||
    targetText.includes(query)
  )) {
    return 0;
  }

  if (provider === query) return 1000;
  // Tiers: scoped form `bai/` (900) > provider prefix (800) > model-id
  // prefix (600) > plain substring (200).
  if (query.endsWith("/") && targetText.startsWith(query)) {
    return 900;
  }
  if (provider.startsWith(query)) return 800;
  if (modelId.startsWith(query)) return 600;
  return 200;
}

/**
 * Filter and rank Model Override targets for the picker's search box.
 *
 * - No query: first 80 targets in catalog order (previous behavior, unchanged).
 * - With a query: same substring fields as before, ranked by relevance so the
 *   intended provider leads, windowed at 300 so a full provider match is never
 *   crowded out by weaker matches.
 *
 * Ties keep catalog order (explicit index tiebreak, not sort stability).
 */
export function filterModelOverrideTargets(
  targets: readonly ModelOverrideTarget[],
  query: string
): ModelOverrideTarget[] {
  const q = normalizeForSearch(query);
  const cap = q ? FILTERED_MODEL_OVERRIDE_TARGET_WINDOW : DEFAULT_MODEL_OVERRIDE_TARGET_WINDOW;
  if (!q) return targets.slice(0, cap);

  const scored: Array<{ target: ModelOverrideTarget; score: number; index: number }> = [];
  for (let index = 0; index < targets.length; index++) {
    const target = targets[index];
    const score = scoreModelOverrideTarget(target, q);
    if (score > 0) scored.push({ target, score, index });
  }
  scored.sort((a, b) => b.score - a.score || a.index - b.index);
  return scored.slice(0, cap).map((entry) => entry.target);
}