feat(ai): Add auto-generated TypeScript models with factory function

- Generate models.generated.ts from models.json with proper types
- Categorize providers: OpenAI (Responses), OpenAI-compatible, Anthropic, Gemini
- Create createLLM() factory with TypeScript overloads for type safety
- Auto-detect base URLs and environment variables for providers
- Support 353 models across 39 providers with full autocompletion
- Exclude generated file from git (rebuilt on npm build)
This commit is contained in:
Mario Zechner 2025-08-25 21:31:29 +02:00
parent 9b8ea585bd
commit da66a97ea7
6 changed files with 414 additions and 2 deletions

View file

@ -0,0 +1,265 @@
#!/usr/bin/env tsx
import { readFileSync, writeFileSync } from "fs";
import { join } from "path";
// Load the models.json file
const data = JSON.parse(readFileSync(join(process.cwd(), "src/models.json"), "utf-8"));
// Categorize providers by their API type
const openaiModels: Record<string, any> = {};
const openaiCompatibleProviders: Record<string, any> = {};
const anthropicModels: Record<string, any> = {};
const geminiModels: Record<string, any> = {};
for (const [providerId, provider] of Object.entries(data)) {
const p = provider as any;
if (providerId === "openai") {
// All OpenAI models use the Responses API
openaiModels[providerId] = p;
} else if (providerId === "anthropic" || providerId === "google-vertex-anthropic") {
// Anthropic direct and via Vertex
anthropicModels[providerId] = p;
} else if (providerId === "google" || providerId === "google-vertex") {
// Google Gemini models
geminiModels[providerId] = p;
} else if (p.npm === "@ai-sdk/openai-compatible" ||
p.npm === "@ai-sdk/groq" ||
p.npm === "@ai-sdk/cerebras" ||
p.npm === "@ai-sdk/fireworks" ||
p.npm === "@ai-sdk/openrouter" ||
p.npm === "@ai-sdk/openai" && providerId !== "openai" ||
p.api?.includes("/v1") ||
["together", "ollama", "llama", "github-models", "groq", "cerebras", "openrouter", "fireworks"].includes(providerId)) {
// OpenAI-compatible providers - they all speak the OpenAI completions API
// Set default base URLs for known providers
if (!p.api) {
switch (providerId) {
case "groq": p.api = "https://api.groq.com/openai/v1"; break;
case "cerebras": p.api = "https://api.cerebras.com/v1"; break;
case "together": p.api = "https://api.together.xyz/v1"; break;
case "fireworks": p.api = "https://api.fireworks.ai/v1"; break;
}
}
openaiCompatibleProviders[providerId] = p;
}
}
// Generate the TypeScript file
let output = `// This file is auto-generated by scripts/generate-models.ts
// Do not edit manually - run 'npm run generate-models' to update
import type { ModalityInput, ModalityOutput } from "./models.js";
export interface ModelData {
id: string;
name: string;
reasoning: boolean;
tool_call: boolean;
attachment: boolean;
temperature: boolean;
knowledge?: string;
release_date: string;
last_updated: string;
modalities: {
input: ModalityInput[];
output: ModalityOutput[];
};
open_weights: boolean;
limit: {
context: number;
output: number;
};
cost?: {
input: number;
output: number;
cache_read?: number;
cache_write?: number;
};
}
export interface ProviderData {
id: string;
name: string;
baseUrl?: string;
env?: string[];
models: Record<string, ModelData>;
}
`;
// Generate OpenAI models
output += `// OpenAI models - all use OpenAIResponsesLLM\n`;
output += `export const OPENAI_MODELS = {\n`;
for (const [providerId, provider] of Object.entries(openaiModels)) {
const p = provider as any;
for (const [modelId, model] of Object.entries(p.models || {})) {
const m = model as any;
output += ` "${modelId}": ${JSON.stringify(m, null, 8).split('\n').join('\n ')},\n`;
}
}
output += `} as const;\n\n`;
// Generate OpenAI-compatible providers
output += `// OpenAI-compatible providers - use OpenAICompletionsLLM\n`;
output += `export const OPENAI_COMPATIBLE_PROVIDERS = {\n`;
for (const [providerId, provider] of Object.entries(openaiCompatibleProviders)) {
const p = provider as any;
output += ` "${providerId}": {\n`;
output += ` id: "${providerId}",\n`;
output += ` name: "${p.name}",\n`;
if (p.api) {
output += ` baseUrl: "${p.api}",\n`;
}
if (p.env) {
output += ` env: ${JSON.stringify(p.env)},\n`;
}
output += ` models: {\n`;
for (const [modelId, model] of Object.entries(p.models || {})) {
const m = model as any;
output += ` "${modelId}": ${JSON.stringify(m, null, 12).split('\n').join('\n ')},\n`;
}
output += ` }\n`;
output += ` },\n`;
}
output += `} as const;\n\n`;
// Generate Anthropic models (avoiding duplicates)
output += `// Anthropic models - use AnthropicLLM\n`;
output += `export const ANTHROPIC_MODELS = {\n`;
const seenAnthropicModels = new Set<string>();
for (const [providerId, provider] of Object.entries(anthropicModels)) {
const p = provider as any;
for (const [modelId, model] of Object.entries(p.models || {})) {
if (!seenAnthropicModels.has(modelId)) {
seenAnthropicModels.add(modelId);
const m = model as any;
output += ` "${modelId}": ${JSON.stringify(m, null, 8).split('\n').join('\n ')},\n`;
}
}
}
output += `} as const;\n\n`;
// Generate Gemini models (avoiding duplicates)
output += `// Gemini models - use GeminiLLM\n`;
output += `export const GEMINI_MODELS = {\n`;
const seenGeminiModels = new Set<string>();
for (const [providerId, provider] of Object.entries(geminiModels)) {
const p = provider as any;
for (const [modelId, model] of Object.entries(p.models || {})) {
if (!seenGeminiModels.has(modelId)) {
seenGeminiModels.add(modelId);
const m = model as any;
output += ` "${modelId}": ${JSON.stringify(m, null, 8).split('\n').join('\n ')},\n`;
}
}
}
output += `} as const;\n\n`;
// Generate type helpers
output += `// Type helpers\n`;
output += `export type OpenAIModel = keyof typeof OPENAI_MODELS;\n`;
output += `export type OpenAICompatibleProvider = keyof typeof OPENAI_COMPATIBLE_PROVIDERS;\n`;
output += `export type AnthropicModel = keyof typeof ANTHROPIC_MODELS;\n`;
output += `export type GeminiModel = keyof typeof GEMINI_MODELS;\n\n`;
// Generate the factory function
output += `// Factory function implementation\n`;
output += `import { OpenAIResponsesLLM } from "./providers/openai-responses.js";\n`;
output += `import { OpenAICompletionsLLM } from "./providers/openai-completions.js";\n`;
output += `import { AnthropicLLM } from "./providers/anthropic.js";\n`;
output += `import { GeminiLLM } from "./providers/gemini.js";\n`;
output += `import type { LLM, LLMOptions } from "./types.js";\n\n`;
output += `export interface CreateLLMOptions {
apiKey?: string;
baseUrl?: string;
}
// Overloads for type safety
export function createLLM(
provider: "openai",
model: OpenAIModel,
options?: CreateLLMOptions
): OpenAIResponsesLLM;
export function createLLM(
provider: OpenAICompatibleProvider,
model: string, // We'll validate at runtime
options?: CreateLLMOptions
): OpenAICompletionsLLM;
export function createLLM(
provider: "anthropic",
model: AnthropicModel,
options?: CreateLLMOptions
): AnthropicLLM;
export function createLLM(
provider: "gemini",
model: GeminiModel,
options?: CreateLLMOptions
): GeminiLLM;
// Implementation
export function createLLM(
provider: string,
model: string,
options?: CreateLLMOptions
): LLM<LLMOptions> {
const apiKey = options?.apiKey || process.env[getEnvVar(provider)];
if (provider === "openai") {
return new OpenAIResponsesLLM(model, apiKey);
}
if (provider === "anthropic") {
return new AnthropicLLM(model, apiKey);
}
if (provider === "gemini") {
return new GeminiLLM(model, apiKey);
}
// OpenAI-compatible providers
if (provider in OPENAI_COMPATIBLE_PROVIDERS) {
const providerData = OPENAI_COMPATIBLE_PROVIDERS[provider as OpenAICompatibleProvider];
const baseUrl = options?.baseUrl || providerData.baseUrl;
return new OpenAICompletionsLLM(model, apiKey, baseUrl);
}
throw new Error(\`Unknown provider: \${provider}\`);
}
// Helper to get the default environment variable for a provider
function getEnvVar(provider: string): string {
switch (provider) {
case "openai": return "OPENAI_API_KEY";
case "anthropic": return "ANTHROPIC_API_KEY";
case "gemini": return "GEMINI_API_KEY";
case "groq": return "GROQ_API_KEY";
case "cerebras": return "CEREBRAS_API_KEY";
case "together": return "TOGETHER_API_KEY";
case "openrouter": return "OPENROUTER_API_KEY";
default: return \`\${provider.toUpperCase()}_API_KEY\`;
}
}
`;
// Write the generated file
writeFileSync(join(process.cwd(), "src/models.generated.ts"), output);
console.log("✅ Generated src/models.generated.ts");
// Count statistics
const openaiCount = Object.values(openaiModels).reduce((acc, p: any) => acc + Object.keys(p.models || {}).length, 0);
const compatCount = Object.values(openaiCompatibleProviders).reduce((acc, p: any) => acc + Object.keys(p.models || {}).length, 0);
const anthropicCount = Object.values(anthropicModels).reduce((acc, p: any) => acc + Object.keys(p.models || {}).length, 0);
const geminiCount = Object.values(geminiModels).reduce((acc, p: any) => acc + Object.keys(p.models || {}).length, 0);
console.log(`\nModel counts:`);
console.log(` OpenAI (Responses API): ${openaiCount} models`);
console.log(` OpenAI-compatible: ${compatCount} models across ${Object.keys(openaiCompatibleProviders).length} providers`);
console.log(` Anthropic: ${anthropicCount} models`);
console.log(` Gemini: ${geminiCount} models`);
console.log(` Total: ${openaiCount + compatCount + anthropicCount + geminiCount} models`);