@animus-labs/cortex 0.2.2 → 0.2.4

package/src/utility-model-inference.ts

@@ -0,0 +1,203 @@
+type RawModel = Record<string, unknown>;
+
+const MIN_UTILITY_CONTEXT_WINDOW = 32_000;
+
+const SPECIAL_PURPOSE_MODEL_PATTERN = /(?:embedding|embed|rerank|moderation|whisper|tts|audio|speech|image-generation|vision|live|deep-research|safety|safeguard|guard|search|transcrib)/i;
+
+const UTILITY_TERMS: Array<{ pattern: RegExp; score: number }> = [
+  { pattern: /(?:^|[\s._/-])flash[\s._/-]?lite(?:$|[\s._/-])/, score: 110 },
+  { pattern: /(?:^|[\s._/-])nano(?:$|[\s._/-])/, score: 100 },
+  { pattern: /(?:^|[\s._/-])mini(?:$|[\s._/-])/, score: 95 },
+  { pattern: /(?:^|[\s._/-])haiku(?:$|[\s._/-])/, score: 95 },
+  { pattern: /(?:^|[\s._/-])small(?:$|[\s._/-])/, score: 85 },
+  { pattern: /(?:^|[\s._/-])fast(?:$|[\s._/-])/, score: 80 },
+  { pattern: /(?:^|[\s._/-])spark(?:$|[\s._/-])/, score: 80 },
+  { pattern: /(?:^|[\s._/-])instant(?:$|[\s._/-])/, score: 75 },
+  { pattern: /(?:^|[\s._/-])lite(?:$|[\s._/-])/, score: 70 },
+  { pattern: /(?:^|[\s._/-])flash(?:$|[\s._/-])/, score: 65 },
+  { pattern: /(?:^|[\s._/-])(?:7|8)b(?:$|[\s._/-])/, score: 65 },
+  { pattern: /(?:^|[\s._/-])(?:12|20)b(?:$|[\s._/-])/, score: 45 },
+  { pattern: /(?:^|[\s._/-])32b(?:$|[\s._/-])/, score: 25 },
+];
+
+interface UtilityCandidate {
+  model: RawModel;
+  id: string;
+  name: string;
+  utilityScore: number;
+  recencyScore: number;
+  costScore: number;
+}
+
+export function inferUtilityModel(models: readonly RawModel[] | null | undefined): RawModel | null {
+  if (!Array.isArray(models)) return null;
+
+  const capable = models
+    .map(toUtilityCandidate)
+    .filter((candidate): candidate is UtilityCandidate => candidate !== null);
+
+  const utilityCandidates = capable.filter(candidate => candidate.utilityScore > 0);
+  if (utilityCandidates.length > 0) {
+    return [...utilityCandidates].sort(compareUtilityCandidates)[0]!.model;
+  }
+  if (capable.length === 0) return null;
+
+  return [...capable].sort(compareFallbackCandidates)[0]!.model;
+}
+
+export function inferUtilityModelId(models: readonly RawModel[] | null | undefined): string | null {
+  const model = inferUtilityModel(models);
+  const id = model?.['id'];
+  if (typeof id === 'string') return id;
+  const name = model?.['name'];
+  return typeof name === 'string' ? name : null;
+}
+
+function toUtilityCandidate(model: RawModel): UtilityCandidate | null {
+  const id = getString(model['id']) ?? getString(model['name']);
+  if (!id) return null;
+
+  const name = getString(model['name']) ?? id;
+  const searchable = `${id} ${name}`.toLowerCase();
+  if (SPECIAL_PURPOSE_MODEL_PATTERN.test(searchable)) return null;
+
+  if (!supportsText(model)) return null;
+
+  const contextWindow = getNumber(model['contextWindow']) ?? 0;
+  if (contextWindow > 0 && contextWindow < MIN_UTILITY_CONTEXT_WINDOW) return null;
+
+  return {
+    model,
+    id,
+    name,
+    utilityScore: inferUtilityScore(searchable),
+    recencyScore: inferRecencyScore(searchable),
+    costScore: inferCostScore(model),
+  };
+}
+
+function compareUtilityCandidates(a: UtilityCandidate, b: UtilityCandidate): number {
+  if (b.recencyScore !== a.recencyScore) return b.recencyScore - a.recencyScore;
+  if (a.costScore !== b.costScore) return a.costScore - b.costScore;
+  if (b.utilityScore !== a.utilityScore) return b.utilityScore - a.utilityScore;
+  return a.id.localeCompare(b.id);
+}
+
+function compareFallbackCandidates(a: UtilityCandidate, b: UtilityCandidate): number {
+  if (a.costScore !== b.costScore) return a.costScore - b.costScore;
+  if (b.recencyScore !== a.recencyScore) return b.recencyScore - a.recencyScore;
+  return a.id.localeCompare(b.id);
+}
+
+function supportsText(model: RawModel): boolean {
+  const input = model['input'];
+  if (!Array.isArray(input)) return true;
+  return input.includes('text');
+}
+
+function inferUtilityScore(searchable: string): number {
+  let score = 0;
+  for (const term of UTILITY_TERMS) {
+    if (term.pattern.test(searchable)) {
+      score = Math.max(score, term.score);
+    }
+  }
+  return score;
+}
+
+function inferRecencyScore(searchable: string): number {
+  const dateScore = inferDateScore(searchable);
+  const versionScore = inferVersionScore(searchable);
+  return Math.max(dateScore, versionScore);
+}
+
+function inferDateScore(searchable: string): number {
+  let score = 0;
+
+  for (const match of searchable.matchAll(/20\d{6}/g)) {
+    const value = Number(match[0]);
+    if (isValidDateScore(value)) {
+      score = Math.max(score, value);
+    }
+  }
+
+  for (const match of searchable.matchAll(/(20\d{2})[-_/](0[1-9]|1[0-2])/g)) {
+    score = Math.max(score, Number(match[1]) * 10_000 + Number(match[2]) * 100);
+  }
+
+  for (const match of searchable.matchAll(/(0[1-9]|1[0-2])[-_/](20\d{2})/g)) {
+    score = Math.max(score, Number(match[2]) * 10_000 + Number(match[1]) * 100);
+  }
+
+  for (const match of searchable.matchAll(/(?:^|[^\d])(\d{4})(?:$|[^\da-z])/g)) {
+    const raw = match[1]!;
+    const year = Number(raw.slice(0, 2));
+    const month = Number(raw.slice(2, 4));
+    if (year >= 20 && year <= 40 && month >= 1 && month <= 12) {
+      score = Math.max(score, 20_000_000 + year * 10_000 + month * 100);
+    }
+  }
+
+  return score;
+}
+
+function inferVersionScore(searchable: string): number {
+  const scrubbed = searchable
+    .replace(/20\d{6}/g, ' ')
+    .replace(/(20\d{2})[-_/](0[1-9]|1[0-2])/g, ' ')
+    .replace(/(0[1-9]|1[0-2])[-_/](20\d{2})/g, ' ')
+    .replace(/(?:^|[^\d])(\d{4})(?:$|[^\da-z])/g, ' ')
+    .replace(/\b\d+(?:\.\d+)?b\b/g, ' ');
+
+  let score = 0;
+  for (const match of scrubbed.matchAll(/\d+(?:\.\d+)+/g)) {
+    score = Math.max(score, scoreVersionParts(match[0]!.split('.').map(Number)));
+  }
+
+  const tokens = scrubbed.split(/[^a-z0-9]+/).filter(Boolean);
+  for (let i = 0; i < tokens.length; i++) {
+    if (!/^\d+$/.test(tokens[i]!)) continue;
+    const parts: number[] = [];
+    for (let j = i; j < tokens.length && /^\d+$/.test(tokens[j]!) && parts.length < 4; j++) {
+      parts.push(Number(tokens[j]));
+    }
+    if (parts.length >= 2) {
+      score = Math.max(score, scoreVersionParts(parts));
+    }
+  }
+
+  return score;
+}
+
+function scoreVersionParts(parts: number[]): number {
+  const weights = [1_000_000, 10_000, 100, 1];
+  return parts.slice(0, weights.length).reduce((score, part, index) => (
+    Number.isFinite(part) ? score + part * weights[index]! : score
+  ), 0);
+}
+
+function inferCostScore(model: RawModel): number {
+  const cost = model['cost'] ?? model['pricing'];
+  if (!cost || typeof cost !== 'object') return Number.MAX_SAFE_INTEGER;
+
+  const rawCost = cost as RawModel;
+  const input = getNumber(rawCost['input']) ?? 0;
+  const output = getNumber(rawCost['output']) ?? 0;
+  if (input === 0 && output === 0) return Number.MAX_SAFE_INTEGER - 1;
+  return input + output * 3;
+}
+
+function isValidDateScore(value: number): boolean {
+  const year = Math.floor(value / 10_000);
+  const month = Math.floor((value % 10_000) / 100);
+  const day = value % 100;
+  return year >= 2020 && year <= 2040 && month >= 1 && month <= 12 && day >= 1 && day <= 31;
+}
+
+function getString(value: unknown): string | null {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+function getNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}