@auto-engineer/model-factory 1.58.0 → 1.60.0

package/package.json

@@ -22,7 +22,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.58.0",
+  "version": "1.60.0",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/index.specs.ts

@@ -1,11 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-const stubModel = (provider: string) => (model: string) => ({
-  specificationVersion: 'v3',
-  modelId: model,
-  provider,
-});
-
 vi.mock('@ai-sdk/openai-compatible', () => ({
   createOpenAICompatible: ({ name, baseURL, apiKey }: { name: string; baseURL: string; apiKey: string }) => ({
     chatModel: (model: string) => ({
@@ -16,11 +10,6 @@ vi.mock('@ai-sdk/openai-compatible', () => ({
   }),
 }));
 
-vi.mock('@ai-sdk/openai', () => ({ createOpenAI: () => stubModel('openai') }));
-vi.mock('@ai-sdk/anthropic', () => ({ createAnthropic: () => stubModel('anthropic') }));
-vi.mock('@ai-sdk/google', () => ({ createGoogleGenerativeAI: () => stubModel('google') }));
-vi.mock('@ai-sdk/xai', () => ({ createXai: () => stubModel('xai') }));
-
 const savedEnv = { ...process.env };
 
 beforeEach(() => {
@@ -31,169 +20,61 @@ afterEach(() => {
   process.env = { ...savedEnv };
 });
 
-describe('createModelFromEnv', () => {
-  describe('custom provider', () => {
-    it('creates model using CUSTOM_PROVIDER env vars with default model', async () => {
-      process.env.CUSTOM_PROVIDER_NAME = 'litellm';
-      process.env.CUSTOM_PROVIDER_BASE_URL = 'https://gateway.example.com/v1';
-      process.env.CUSTOM_PROVIDER_API_KEY = 'sk-test';
-      process.env.DEFAULT_AI_PROVIDER = 'custom';
-
-      const { createModelFromEnv, DEFAULT_MODELS } = await import('./index.js');
-      const model = createModelFromEnv();
-
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: DEFAULT_MODELS.custom,
-        provider: 'litellm:https://gateway.example.com/v1:sk-test',
-      });
-    });
-
-    it('uses options.model override', async () => {
-      process.env.CUSTOM_PROVIDER_BASE_URL = 'https://gw.example.com/v1';
-
-      const { createModelFromEnv } = await import('./index.js');
-      const model = createModelFromEnv({ model: 'my-custom-model' });
-
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: 'my-custom-model',
-        provider: 'custom:https://gw.example.com/v1:',
-      });
-    });
-
-    it('uses DEFAULT_AI_MODEL env var when options.model is unset', async () => {
-      process.env.CUSTOM_PROVIDER_BASE_URL = 'https://gw.example.com/v1';
-      process.env.DEFAULT_AI_MODEL = 'env-override-model';
-
-      const { createModelFromEnv } = await import('./index.js');
-      const model = createModelFromEnv();
+function setRequiredEnv(overrides?: Partial<Record<string, string>>) {
+  process.env.CUSTOM_PROVIDER_NAME = 'litellm';
+  process.env.CUSTOM_PROVIDER_BASE_URL = 'https://gateway.example.com/v1';
+  process.env.CUSTOM_PROVIDER_API_KEY = 'sk-test';
+  process.env.CUSTOM_PROVIDER_DEFAULT_MODEL = 'xai/grok-code-fast-1';
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
 
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: 'env-override-model',
-        provider: 'custom:https://gw.example.com/v1:',
-      });
-    });
-
-    it('defaults to custom provider when DEFAULT_AI_PROVIDER is unset', async () => {
-      process.env.CUSTOM_PROVIDER_BASE_URL = 'https://gw.example.com/v1';
-      delete process.env.DEFAULT_AI_PROVIDER;
-
-      const { createModelFromEnv } = await import('./index.js');
-      const model = createModelFromEnv();
-
-      expect(model).toEqual(
-        expect.objectContaining({
-          specificationVersion: 'v3',
-          provider: 'custom:https://gw.example.com/v1:',
-        }),
-      );
-    });
-
-    it('throws when CUSTOM_PROVIDER_BASE_URL is missing', async () => {
-      process.env.DEFAULT_AI_PROVIDER = 'custom';
-      delete process.env.CUSTOM_PROVIDER_BASE_URL;
+describe('createModelFromEnv', () => {
+  it('creates model from all 4 env vars', async () => {
+    setRequiredEnv();
 
-      const { createModelFromEnv } = await import('./index.js');
+    const { createModelFromEnv } = await import('./index.js');
+    const model = createModelFromEnv();
 
-      expect(() => createModelFromEnv()).toThrow('CUSTOM_PROVIDER_BASE_URL is required when using the custom provider');
+    expect(model).toEqual({
+      specificationVersion: 'v3',
+      modelId: 'xai/grok-code-fast-1',
+      provider: 'litellm:https://gateway.example.com/v1:sk-test',
     });
   });
 
-  describe('direct providers', () => {
-    it('creates openai model with default model name', async () => {
-      const { createModelFromEnv, DEFAULT_MODELS } = await import('./index.js');
-      const model = createModelFromEnv({ provider: 'openai' });
-
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: DEFAULT_MODELS.openai,
-        provider: 'openai',
-      });
-    });
+  it('throws when CUSTOM_PROVIDER_NAME is missing', async () => {
+    setRequiredEnv({ CUSTOM_PROVIDER_NAME: undefined });
 
-    it('creates anthropic model with default model name', async () => {
-      const { createModelFromEnv, DEFAULT_MODELS } = await import('./index.js');
-      const model = createModelFromEnv({ provider: 'anthropic' });
-
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: DEFAULT_MODELS.anthropic,
-        provider: 'anthropic',
-      });
-    });
-
-    it('creates google model with default model name', async () => {
-      const { createModelFromEnv, DEFAULT_MODELS } = await import('./index.js');
-      const model = createModelFromEnv({ provider: 'google' });
-
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: DEFAULT_MODELS.google,
-        provider: 'google',
-      });
-    });
-
-    it('creates xai model with default model name', async () => {
-      const { createModelFromEnv, DEFAULT_MODELS } = await import('./index.js');
-      const model = createModelFromEnv({ provider: 'xai' });
-
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: DEFAULT_MODELS.xai,
-        provider: 'xai',
-      });
-    });
-
-    it('reads provider from DEFAULT_AI_PROVIDER env var', async () => {
-      process.env.DEFAULT_AI_PROVIDER = 'anthropic';
-
-      const { createModelFromEnv, DEFAULT_MODELS } = await import('./index.js');
-      const model = createModelFromEnv();
-
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: DEFAULT_MODELS.anthropic,
-        provider: 'anthropic',
-      });
-    });
-
-    it('options.provider overrides DEFAULT_AI_PROVIDER env var', async () => {
-      process.env.DEFAULT_AI_PROVIDER = 'openai';
-
-      const { createModelFromEnv, DEFAULT_MODELS } = await import('./index.js');
-      const model = createModelFromEnv({ provider: 'xai' });
+    const { createModelFromEnv } = await import('./index.js');
+    expect(() => createModelFromEnv()).toThrow('Missing required environment variable: CUSTOM_PROVIDER_NAME');
+  });
 
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: DEFAULT_MODELS.xai,
-        provider: 'xai',
-      });
-    });
+  it('throws when CUSTOM_PROVIDER_BASE_URL is missing', async () => {
+    setRequiredEnv({ CUSTOM_PROVIDER_BASE_URL: undefined });
 
-    it('uses options.model for direct provider', async () => {
-      const { createModelFromEnv } = await import('./index.js');
-      const model = createModelFromEnv({ provider: 'openai', model: 'gpt-4-turbo' });
+    const { createModelFromEnv } = await import('./index.js');
+    expect(() => createModelFromEnv()).toThrow('Missing required environment variable: CUSTOM_PROVIDER_BASE_URL');
+  });
 
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: 'gpt-4-turbo',
-        provider: 'openai',
-      });
-    });
+  it('throws when CUSTOM_PROVIDER_API_KEY is missing', async () => {
+    setRequiredEnv({ CUSTOM_PROVIDER_API_KEY: undefined });
 
-    it('uses DEFAULT_AI_MODEL env var for direct provider', async () => {
-      process.env.DEFAULT_AI_MODEL = 'custom-model-name';
+    const { createModelFromEnv } = await import('./index.js');
+    expect(() => createModelFromEnv()).toThrow('Missing required environment variable: CUSTOM_PROVIDER_API_KEY');
+  });
 
-      const { createModelFromEnv } = await import('./index.js');
-      const model = createModelFromEnv({ provider: 'openai' });
+  it('throws when CUSTOM_PROVIDER_DEFAULT_MODEL is missing', async () => {
+    setRequiredEnv({ CUSTOM_PROVIDER_DEFAULT_MODEL: undefined });
 
-      expect(model).toEqual({
-        specificationVersion: 'v3',
-        modelId: 'custom-model-name',
-        provider: 'openai',
-      });
-    });
+    const { createModelFromEnv } = await import('./index.js');
+    expect(() => createModelFromEnv()).toThrow('Missing required environment variable: CUSTOM_PROVIDER_DEFAULT_MODEL');
   });
 });

package/src/index.ts

@@ -1,49 +1,19 @@
-import { createAnthropic } from '@ai-sdk/anthropic';
-import { createGoogleGenerativeAI } from '@ai-sdk/google';
-import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-import { createXai } from '@ai-sdk/xai';
 import type { LanguageModel } from 'ai';
 
-export type Provider = 'openai' | 'anthropic' | 'google' | 'xai' | 'custom';
-
-export const DEFAULT_MODELS: Record<Provider, string> = {
-  openai: 'gpt-4o',
-  anthropic: 'claude-sonnet-4-20250514',
-  google: 'gemini-2.0-flash',
-  xai: 'grok-3',
-  custom: 'claude-sonnet-4-20250514',
-};
-
-interface CreateModelOptions {
-  provider?: Provider;
-  model?: string;
+function requireEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
 }
 
-export function createModelFromEnv(options?: CreateModelOptions): LanguageModel {
-  const provider = options?.provider ?? (process.env.DEFAULT_AI_PROVIDER as Provider | undefined) ?? 'custom';
-  const modelName = options?.model ?? process.env.DEFAULT_AI_MODEL ?? DEFAULT_MODELS[provider];
-
-  if (provider === 'custom') {
-    const name = process.env.CUSTOM_PROVIDER_NAME ?? 'custom';
-    const baseURL = process.env.CUSTOM_PROVIDER_BASE_URL;
-    const apiKey = process.env.CUSTOM_PROVIDER_API_KEY ?? '';
+export function createModelFromEnv(): LanguageModel {
+  const name = requireEnv('CUSTOM_PROVIDER_NAME');
+  const baseURL = requireEnv('CUSTOM_PROVIDER_BASE_URL');
+  const apiKey = requireEnv('CUSTOM_PROVIDER_API_KEY');
+  const model = requireEnv('CUSTOM_PROVIDER_DEFAULT_MODEL');
 
-    if (!baseURL) {
-      throw new Error('CUSTOM_PROVIDER_BASE_URL is required when using the custom provider');
-    }
-
-    return createOpenAICompatible({ name, baseURL, apiKey }).chatModel(modelName) as unknown as LanguageModel;
-  }
-
-  switch (provider) {
-    case 'openai':
-      return createOpenAI()(modelName) as unknown as LanguageModel;
-    case 'anthropic':
-      return createAnthropic()(modelName) as unknown as LanguageModel;
-    case 'google':
-      return createGoogleGenerativeAI()(modelName) as unknown as LanguageModel;
-    case 'xai':
-      return createXai()(modelName) as unknown as LanguageModel;
-  }
+  return createOpenAICompatible({ name, baseURL, apiKey }).chatModel(model) as unknown as LanguageModel;
 }