@funkai/models 0.2.1 → 0.3.1

package/scripts/generate-models.ts

@@ -6,10 +6,6 @@ import { lauf, z } from "laufen";
 const API_URL = "https://models.dev/api.json";
 const STALE_MS = 24 * 60 * 60 * 1000;
 
-// ---------------------------------------------------------------------------
-// Banner
-// ---------------------------------------------------------------------------
-
 const BANNER = `// ──────────────────────────────────────────────────────────────
 // ███████╗██╗   ██╗███╗   ██╗██╗  ██╗ █████╗ ██╗
 // ██╔════╝██║   ██║████╗  ██║██║ ██╔╝██╔══██╗██║
@@ -23,10 +19,6 @@ const BANNER = `// ────────────────────
 // Update: pnpm --filter=@funkai/models generate:models
 // ──────────────────────────────────────────────────────────────`;
 
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
 interface ProviderEntry {
   name: string;
   prefix: string;
@@ -58,16 +50,12 @@ interface ApiProvider {
   models: Record<string, ApiModel>;
 }
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
 /**
  * Convert a provider key to a TypeScript constant name.
  * e.g. "openai" → "OPENAI_MODELS", "meta-llama" → "META_LLAMA_MODELS"
  */
 function toConstName(provider: string): string {
-  return `${provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_MODELS`;
+  return `${provider.toUpperCase().replaceAll(/[^A-Z0-9]/g, "_")}_MODELS`;
 }
 
 /**
@@ -75,14 +63,24 @@ function toConstName(provider: string): string {
  * e.g. "OpenAI" → "openAI", "GoogleVertex" → "googleVertex", "XAI" → "xAI"
  */
 function lowerFirst(s: string): string {
-  return s.length === 0 ? s : s[0]!.toLowerCase() + s.slice(1);
+  if (s.length === 0) {
+    return s;
+  }
+  const [first] = s;
+  if (first === undefined) {
+    return s;
+  }
+  return first.toLowerCase() + s.slice(1);
 }
 
 /**
  * Return the correct indefinite article ("a" or "an") for a word.
  */
 function article(word: string): string {
-  return /^[aeiou]/i.test(word) ? "an" : "a";
+  if (/^[aeiou]/i.test(word)) {
+    return "an";
+  }
+  return "a";
 }
 
 /**
@@ -98,8 +96,12 @@ function toPerToken(perMillion: number): number {
  * very small values.
  */
 function fmtNum(n: number): string {
-  if (n === 0) return "0";
-  if (n < 0.0000001) return n.toExponential();
+  if (n === 0) {
+    return "0";
+  }
+  if (n < 0.000_000_1) {
+    return n.toExponential();
+  }
   return String(n);
 }
 
@@ -107,18 +109,32 @@ function fmtNum(n: number): string {
  * Build the pricing object literal string for a model.
  */
 function buildPricing(cost: ApiModel["cost"]): string {
-  const input = toPerToken(cost?.input ?? 0);
-  const output = toPerToken(cost?.output ?? 0);
+  const costInput: number = (() => {
+    if (cost !== undefined && cost !== null && cost.input !== undefined && cost.input !== null) {
+      return cost.input;
+    }
+    return 0;
+  })();
+  const costOutput: number = (() => {
+    if (cost !== undefined && cost !== null && cost.output !== undefined && cost.output !== null) {
+      return cost.output;
+    }
+    return 0;
+  })();
+  const input = toPerToken(costInput);
+  const output = toPerToken(costOutput);
   const parts: string[] = [`input: ${fmtNum(input)}`, `output: ${fmtNum(output)}`];
 
-  if (cost?.cache_read != null && cost.cache_read > 0) {
-    parts.push(`cacheRead: ${fmtNum(toPerToken(cost.cache_read))}`);
-  }
-  if (cost?.cache_write != null && cost.cache_write > 0) {
-    parts.push(`cacheWrite: ${fmtNum(toPerToken(cost.cache_write))}`);
-  }
-  if (cost?.reasoning != null && cost.reasoning > 0) {
-    parts.push(`reasoning: ${fmtNum(toPerToken(cost.reasoning))}`);
+  if (cost !== undefined && cost !== null) {
+    if (cost.cache_read !== undefined && cost.cache_read !== null && cost.cache_read > 0) {
+      parts.push(`cacheRead: ${fmtNum(toPerToken(cost.cache_read))}`);
+    }
+    if (cost.cache_write !== undefined && cost.cache_write !== null && cost.cache_write > 0) {
+      parts.push(`cacheWrite: ${fmtNum(toPerToken(cost.cache_write))}`);
+    }
+    if (cost.reasoning !== undefined && cost.reasoning !== null && cost.reasoning > 0) {
+      parts.push(`reasoning: ${fmtNum(toPerToken(cost.reasoning))}`);
+    }
   }
 
   return `{ ${parts.join(", ")} }`;
@@ -128,8 +144,30 @@ function buildPricing(cost: ApiModel["cost"]): string {
  * Build the modalities object literal string.
  */
 function buildModalities(modalities: ApiModel["modalities"]): string {
-  const input = JSON.stringify(modalities?.input ?? ["text"]);
-  const output = JSON.stringify(modalities?.output ?? ["text"]);
+  const modalInput: string[] = (() => {
+    if (
+      modalities !== undefined &&
+      modalities !== null &&
+      modalities.input !== undefined &&
+      modalities.input !== null
+    ) {
+      return modalities.input;
+    }
+    return ["text"];
+  })();
+  const modalOutput: string[] = (() => {
+    if (
+      modalities !== undefined &&
+      modalities !== null &&
+      modalities.output !== undefined &&
+      modalities.output !== null
+    ) {
+      return modalities.output;
+    }
+    return ["text"];
+  })();
+  const input = JSON.stringify(modalInput);
+  const output = JSON.stringify(modalOutput);
   return `{ input: ${input}, output: ${output} }`;
 }
 
@@ -145,23 +183,45 @@ function buildCapabilities(m: ApiModel): string {
   ].join(", ");
 }
 
+/**
+ * Extract context window and max output from a model's limit field.
+ */
+function getModelLimits(limit: ApiModel["limit"]): { contextWindow: number; maxOutput: number } {
+  if (limit === undefined || limit === null) {
+    return { contextWindow: 0, maxOutput: 0 };
+  }
+  const contextWindow: number = (() => {
+    if (limit.context !== undefined && limit.context !== null) {
+      return limit.context;
+    }
+    return 0;
+  })();
+  const maxOutput: number = (() => {
+    if (limit.output !== undefined && limit.output !== null) {
+      return limit.output;
+    }
+    return 0;
+  })();
+  return { contextWindow, maxOutput };
+}
+
 /**
  * Escape a string for use in a TypeScript single-quoted string literal.
  */
 function escapeStr(s: string): string {
-  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  return s
+    .replaceAll("\\", String.raw`\\`)
+    .replaceAll("'", String.raw`\'`)
+    .replaceAll("\n", String.raw`\n`)
+    .replaceAll("\r", String.raw`\r`);
 }
 
-// ---------------------------------------------------------------------------
-// Staleness check
-// ---------------------------------------------------------------------------
-
 function isFresh(reqPath: string): boolean {
   if (!existsSync(reqPath)) {
     return false;
   }
   try {
-    const timestamp = readFileSync(reqPath, "utf-8").trim();
+    const timestamp = readFileSync(reqPath, "utf8").trim();
     const lastRun = new Date(timestamp).getTime();
     return Date.now() - lastRun < STALE_MS;
   } catch {
@@ -169,10 +229,6 @@ function isFresh(reqPath: string): boolean {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Script
-// ---------------------------------------------------------------------------
-
 export default lauf({
   description: "Fetch model data from models.dev and generate TypeScript catalog files",
   args: {
@@ -195,7 +251,7 @@ export default lauf({
 
     // Read provider config
     const providers: Record<string, ProviderEntry> = JSON.parse(
-      readFileSync(PROVIDERS_PATH, "utf-8"),
+      readFileSync(PROVIDERS_PATH, "utf8"),
     );
     const providerKeys = Object.keys(providers);
 
@@ -233,30 +289,34 @@ export default lauf({
     const providerFiles: { provider: string; constName: string; count: number }[] = [];
 
     for (const providerKey of providerKeys) {
-      const apiProvider = apiData[providerKey]!;
-      const apiModels = apiProvider.models ?? {};
-      const constName = toConstName(providerKey);
-      const lines: string[] = [];
-
-      for (const [, m] of Object.entries(apiModels)) {
-        const id = escapeStr(m.id);
-        const name = escapeStr(m.name ?? m.id);
-        const family = escapeStr(m.family ?? "");
-        const pricing = buildPricing(m.cost);
-        const contextWindow = m.limit?.context ?? 0;
-        const maxOutput = m.limit?.output ?? 0;
-        const modalities = buildModalities(m.modalities);
-        const capabilities = buildCapabilities(m);
-
-        lines.push(
-          `  { id: '${id}', name: '${name}', provider: '${providerKey}', family: '${family}', ` +
-            `pricing: ${pricing}, contextWindow: ${contextWindow}, maxOutput: ${maxOutput}, ` +
-            `modalities: ${modalities}, capabilities: { ${capabilities} } },`,
-        );
-      }
-
-      // Write catalog provider file
-      const catalogContent = `${BANNER}
+      const apiProviderEntry = apiData[providerKey];
+      const providerEntry = providers[providerKey];
+      if (apiProviderEntry !== undefined && providerEntry !== undefined) {
+        if (apiProviderEntry.models === undefined || apiProviderEntry.models === null) {
+          throw new Error(
+            `models.dev API returned no models for configured provider: ${providerKey}`,
+          );
+        }
+        const apiModels = apiProviderEntry.models;
+        const constName = toConstName(providerKey);
+        const lines: string[] = [];
+
+        for (const [, m] of Object.entries(apiModels)) {
+          const id = escapeStr(m.id);
+          const name = escapeStr(m.name ?? m.id);
+          const family = escapeStr(m.family ?? "");
+          const pricing = buildPricing(m.cost);
+          const { contextWindow, maxOutput } = getModelLimits(m.limit);
+          const modalities = buildModalities(m.modalities);
+          const capabilities = buildCapabilities(m);
+
+          lines.push(
+            `  { id: '${id}', name: '${name}', provider: '${providerKey}', family: '${family}', pricing: ${pricing}, contextWindow: ${contextWindow}, maxOutput: ${maxOutput}, modalities: ${modalities}, capabilities: { ${capabilities} } },`,
+          );
+        }
+
+        // Write catalog provider file
+        const catalogContent = `${BANNER}
 
 import type { ModelDefinition } from '../types.js'
 
@@ -265,16 +325,24 @@ ${lines.join("\n")}
 ] as const satisfies readonly ModelDefinition[]
 `;
 
-      const catalogPath = join(CATALOG_DIR, `${providerKey}.ts`);
-      writeFileSync(catalogPath, catalogContent, "utf-8");
-
-      // Write per-provider entry point
-      const prefix = providers[providerKey]!.prefix;
-      const camel = lowerFirst(prefix);
-      const exampleId = escapeStr(Object.values(apiModels)[0]?.id ?? "example-id");
-      const providerName = escapeStr(providers[providerKey]!.name);
-      const art = article(providers[providerKey]!.name);
-      const entryContent = `${BANNER}
+        const catalogPath = join(CATALOG_DIR, `${providerKey}.ts`);
+        writeFileSync(catalogPath, catalogContent, "utf8");
+
+        // Write per-provider entry point
+        const { prefix } = providerEntry;
+        const camel = lowerFirst(prefix);
+        const [firstModel] = Object.values(apiModels);
+        const exampleId = escapeStr(
+          (() => {
+            if (firstModel !== undefined) {
+              return firstModel.id;
+            }
+            return "example-id";
+          })(),
+        );
+        const providerName = escapeStr(providerEntry.name);
+        const art = article(providerEntry.name);
+        const entryContent = `${BANNER}
 
 import type { LiteralUnion } from 'type-fest'
 import type { ModelDefinition } from '../catalog/types.js'
@@ -329,11 +397,12 @@ export function ${camel}Model(id: LiteralUnion<${prefix}ModelId, string>): Model
 }
 `;
 
-      const entryPath = join(ENTRY_DIR, `${providerKey}.ts`);
-      writeFileSync(entryPath, entryContent, "utf-8");
+        const entryPath = join(ENTRY_DIR, `${providerKey}.ts`);
+        writeFileSync(entryPath, entryContent, "utf8");
 
-      ctx.logger.success(`${providerKey} (${lines.length} models)`);
-      providerFiles.push({ provider: providerKey, constName, count: lines.length });
+        ctx.logger.success(`${providerKey} (${lines.length} models)`);
+        providerFiles.push({ provider: providerKey, constName, count: lines.length });
+      }
     }
 
     // Catalog barrel
@@ -353,16 +422,16 @@ ${spreads}
 ] as const satisfies readonly ModelDefinition[]
 `;
 
-    writeFileSync(join(CATALOG_DIR, "index.ts"), catalogBarrel, "utf-8");
+    writeFileSync(join(CATALOG_DIR, "index.ts"), catalogBarrel, "utf8");
     ctx.logger.success("catalog/providers/index.ts (barrel)");
 
     // Write generated entries list for tsdown config
     const entryPoints = providerFiles.map((p) => `src/providers/${p.provider}.ts`);
-    writeFileSync(ENTRIES_PATH, JSON.stringify(entryPoints, null, 2), "utf-8");
+    writeFileSync(ENTRIES_PATH, JSON.stringify(entryPoints, null, 2), "utf8");
     ctx.logger.success(".generated/entries.json");
 
     // Update package.json exports map
-    const pkgRaw = readFileSync(PACKAGE_JSON_PATH, "utf-8");
+    const pkgRaw = readFileSync(PACKAGE_JSON_PATH, "utf8");
     const pkg = JSON.parse(pkgRaw);
 
     const exportsMap: Record<string, { types: string; import: string }> = {
@@ -380,11 +449,11 @@ ${spreads}
     }
 
     pkg.exports = exportsMap;
-    writeFileSync(PACKAGE_JSON_PATH, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    writeFileSync(PACKAGE_JSON_PATH, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
     ctx.logger.success("package.json exports map updated");
 
     // Staleness timestamp
-    writeFileSync(REQ_PATH, new Date().toISOString(), "utf-8");
+    writeFileSync(REQ_PATH, new Date().toISOString(), "utf8");
 
     const totalModels = providerFiles.reduce((sum, p) => sum + p.count, 0);
     ctx.logger.info(`done (${providerFiles.length} providers, ${totalModels} models)`);

package/src/catalog/index.test.ts

@@ -2,11 +2,7 @@ import { describe, expect, it } from "vitest";
 
 import { model, models, MODELS } from "@/catalog/index.js";
 
-// ---------------------------------------------------------------------------
-// MODELS constant
-// ---------------------------------------------------------------------------
-
-describe("MODELS", () => {
+describe("MODELS catalog", () => {
   it("is a non-empty array", () => {
     expect(MODELS.length).toBeGreaterThan(0);
   });
@@ -18,8 +14,8 @@ describe("MODELS", () => {
       expect(typeof m.provider).toBe("string");
       expect(typeof m.pricing.input).toBe("number");
       expect(typeof m.pricing.output).toBe("number");
-      expect(Array.isArray(m.modalities.input)).toBe(true);
-      expect(Array.isArray(m.modalities.output)).toBe(true);
+      expect(Array.isArray(m.modalities.input)).toBeTruthy();
+      expect(Array.isArray(m.modalities.output)).toBeTruthy();
       expect(typeof m.capabilities.reasoning).toBe("boolean");
     }
   });
@@ -34,17 +30,13 @@ describe("MODELS", () => {
     const seen = new Map<string, Set<string>>();
     for (const m of MODELS) {
       const providerSet = seen.get(m.provider) ?? new Set<string>();
-      expect(providerSet.has(m.id)).toBe(false);
+      expect(providerSet.has(m.id)).toBeFalsy();
       providerSet.add(m.id);
       seen.set(m.provider, providerSet);
     }
   });
 });
 
-// ---------------------------------------------------------------------------
-// model()
-// ---------------------------------------------------------------------------
-
 describe("model()", () => {
   it("returns the model definition for a known ID", () => {
     const result = model("gpt-4o-mini");
@@ -66,7 +58,7 @@ describe("model()", () => {
     const result = model("o1");
 
     expect(result).not.toBeNull();
-    expect(result!.capabilities.reasoning).toBe(true);
+    expect(result!.capabilities.reasoning).toBeTruthy();
   });
 
   it("returns model with correct modalities", () => {
@@ -78,10 +70,6 @@ describe("model()", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// models()
-// ---------------------------------------------------------------------------
-
 describe("models()", () => {
   it("returns all models when called without filter", () => {
     const result = models();
@@ -94,7 +82,7 @@ describe("models()", () => {
 
     expect(reasoningModels.length).toBeGreaterThan(0);
     for (const m of reasoningModels) {
-      expect(m.capabilities.reasoning).toBe(true);
+      expect(m.capabilities.reasoning).toBeTruthy();
     }
   });
 
@@ -114,11 +102,11 @@ describe("models()", () => {
   });
 
   it("supports arbitrary filter predicates", () => {
-    const result = models((m) => m.pricing.input > 0.000001);
+    const result = models((m) => m.pricing.input > 0.000_001);
 
     expect(result.length).toBeGreaterThan(0);
     for (const m of result) {
-      expect(m.pricing.input).toBeGreaterThan(0.000001);
+      expect(m.pricing.input).toBeGreaterThan(0.000_001);
     }
   });
 });

package/src/catalog/index.ts

@@ -61,5 +61,8 @@ export function model(id: ModelId): ModelDefinition | null {
  * ```
  */
 export function models(filter?: (m: ModelDefinition) => boolean): readonly ModelDefinition[] {
-  return filter ? MODELS.filter(filter) : MODELS;
+  if (filter) {
+    return MODELS.filter(filter);
+  }
+  return MODELS;
 }