@flowcodex/core 0.3.0

package/tests/provider-factory.test.ts

@@ -0,0 +1,245 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { ModelInfo } from '../src/infrastructure/catalog-parser.js';
+import { DefaultCatalogParser } from '../src/infrastructure/catalog-parser.js';
+import {
+  classifyFamily,
+  createProvider,
+  setProviderConstructors,
+} from '../src/infrastructure/index.js';
+import type {
+  FlowCodexLikeConfig,
+  ProviderConstructors,
+} from '../src/infrastructure/provider-factory.js';
+import type { Provider } from '../src/types/provider.js';
+
+const EMPTY_STREAM = <T>(): AsyncIterable<T> => ({
+  [Symbol.asyncIterator]() {
+    return { next: async () => ({ done: true }) as IteratorResult<T> };
+  },
+});
+
+class FakeAnthropic implements Provider {
+  name = 'anthropic';
+  private baseUrl?: string;
+  constructor(opts: { apiKey: string; baseUrl?: string }) {
+    this.baseUrl = opts.baseUrl;
+  }
+  stream(): AsyncIterable<never> {
+    return EMPTY_STREAM();
+  }
+  async complete() {
+    return { content: [], usage: { input: 0, output: 0 }, stopReason: 'end_turn' };
+  }
+  buildUrl() {
+    return this.baseUrl ?? 'https://api.anthropic.com/v1/messages';
+  }
+}
+class FakeOpenAI implements Provider {
+  name = 'openai';
+  private baseUrl?: string;
+  constructor(opts: { apiKey: string; baseUrl?: string; organization?: string; project?: string }) {
+    this.baseUrl = opts.baseUrl;
+  }
+  stream(): AsyncIterable<never> {
+    return EMPTY_STREAM();
+  }
+  async complete() {
+    return { content: [], usage: { input: 0, output: 0 }, stopReason: 'end_turn' };
+  }
+  buildUrl() {
+    return `${this.baseUrl ?? 'https://api.openai.com'}/v1/chat/completions`;
+  }
+}
+class FakeCompatible implements Provider {
+  name = 'openai-compatible';
+  private baseUrl: string;
+  private extraHeaders?: Record<string, string>;
+  private extraBody?: Record<string, unknown>;
+  constructor(opts: {
+    apiKey: string;
+    baseUrl: string;
+    extraHeaders?: Record<string, string>;
+    extraBody?: Record<string, unknown>;
+  }) {
+    this.baseUrl = opts.baseUrl;
+    this.extraHeaders = opts.extraHeaders;
+    this.extraBody = opts.extraBody;
+  }
+  stream(): AsyncIterable<never> {
+    return EMPTY_STREAM();
+  }
+  async complete() {
+    return { content: [], usage: { input: 0, output: 0 }, stopReason: 'end_turn' };
+  }
+  buildUrl() {
+    return `${this.baseUrl}/chat/completions`;
+  }
+  buildHeaders() {
+    return { authorization: 'Bearer k', ...(this.extraHeaders ?? {}) };
+  }
+}
+
+function makeCatalog(models: ModelInfo[]): DefaultCatalogParser {
+  const parser = new DefaultCatalogParser({ disableNetwork: true });
+  (
+    parser as unknown as { cached: { models: ModelInfo[]; fetchedAt: number; source: string } }
+  ).cached = {
+    models,
+    fetchedAt: Date.now(),
+    source: 'snapshot',
+  };
+  return parser;
+}
+
+const ANTHROPIC_MODELS: ModelInfo[] = [
+  {
+    id: 'claude-sonnet-4-6',
+    name: 'Sonnet',
+    provider: 'anthropic',
+    npm: '@anthropic-ai/sdk',
+    reasoning: false,
+    limit: { context: 200_000, output: 8192 },
+    cost: { input: 3, output: 15 },
+    tool_call: true,
+    modalities: { input: ['text'], output: ['text'] },
+  },
+];
+const OPENAI_MODELS: ModelInfo[] = [
+  {
+    id: 'gpt-4o',
+    name: 'GPT-4o',
+    provider: 'openai',
+    npm: 'openai',
+    reasoning: false,
+    limit: { context: 128_000, output: 4096 },
+    cost: { input: 2.5, output: 10 },
+    tool_call: true,
+    modalities: { input: ['text'], output: ['text'] },
+  },
+];
+const DEEPSEEK_MODELS: ModelInfo[] = [
+  {
+    id: 'deepseek-chat',
+    name: 'DeepSeek Chat',
+    provider: 'deepseek',
+    npm: 'openai-compatible',
+    reasoning: false,
+    limit: { context: 64_000, output: 4096 },
+    cost: { input: 0.14, output: 0.28 },
+    tool_call: true,
+    modalities: { input: ['text'], output: ['text'] },
+  },
+];
+
+const BASE_CONFIG: FlowCodexLikeConfig = {
+  providers: {},
+};
+
+beforeEach(() => {
+  setProviderConstructors({
+    anthropic: FakeAnthropic as unknown as ProviderConstructors['anthropic'],
+    openai: FakeOpenAI as unknown as ProviderConstructors['openai'],
+    openaiCompatible: FakeCompatible as unknown as ProviderConstructors['openaiCompatible'],
+  });
+});
+
+describe('createProvider', () => {
+  it('creates AnthropicProvider for anthropic family', () => {
+    const catalog = makeCatalog(ANTHROPIC_MODELS);
+    const p = createProvider({
+      providerId: 'anthropic',
+      apiKey: 'sk',
+      config: BASE_CONFIG,
+      catalog,
+    });
+    expect(p.name).toBe('anthropic');
+  });
+
+  it('creates OpenAIProvider for openai family from catalog npm', () => {
+    const catalog = makeCatalog(OPENAI_MODELS);
+    const p = createProvider({ providerId: 'openai', apiKey: 'sk', config: BASE_CONFIG, catalog });
+    expect(p.name).toBe('openai');
+  });
+
+  it('creates OpenAICompatibleProvider for openai-compatible family from catalog', () => {
+    const catalog = makeCatalog(DEEPSEEK_MODELS);
+    const config = { providers: { deepseek: { baseUrl: 'https://api.deepseek.com/v1' } } };
+    const p = createProvider({ providerId: 'deepseek', apiKey: 'sk', config, catalog });
+    expect(p.name).toBe('openai-compatible');
+  });
+
+  it('config family override wins over catalog npm', () => {
+    const catalog = makeCatalog(DEEPSEEK_MODELS);
+    const config = {
+      providers: {
+        deepseek: { family: 'openai-compatible', baseUrl: 'https://custom.example.com/v1' },
+      },
+    };
+    const p = createProvider({ providerId: 'deepseek', apiKey: 'sk', config, catalog });
+    expect(p.name).toBe('openai-compatible');
+  });
+
+  it('throws PROVIDER_UNSUPPORTED for unknown provider with no catalog entry', () => {
+    const catalog = makeCatalog(ANTHROPIC_MODELS);
+    expect(() =>
+      createProvider({ providerId: 'unknown', apiKey: 'sk', config: BASE_CONFIG, catalog }),
+    ).toThrow(/not supported/);
+  });
+
+  it('throws PROVIDER_NOT_WIRED for google family', () => {
+    const GEMINI_MODELS: ModelInfo[] = [
+      {
+        id: 'gemini-2-pro',
+        name: 'Gemini 2 Pro',
+        provider: 'google',
+        npm: '@google/genai',
+        reasoning: false,
+        limit: { context: 1_000_000, output: 8192 },
+        tool_call: true,
+        modalities: { input: ['text'], output: ['text'] },
+      },
+    ];
+    const catalog = makeCatalog(GEMINI_MODELS);
+    expect(() =>
+      createProvider({ providerId: 'google', apiKey: 'sk', config: BASE_CONFIG, catalog }),
+    ).toThrow(/not wired/);
+  });
+
+  it('passes baseUrl from config to the provider', () => {
+    const catalog = makeCatalog(DEEPSEEK_MODELS);
+    const config = { providers: { deepseek: { baseUrl: 'https://my-proxy.example.com/v1' } } };
+    const p = createProvider({ providerId: 'deepseek', apiKey: 'sk', config, catalog });
+    const url = (p as unknown as { buildUrl: () => string }).buildUrl.call(p);
+    expect(url).toContain('my-proxy.example.com');
+  });
+
+  it('passes extraHeaders and extraBody from config to compatible provider', () => {
+    const catalog = makeCatalog(DEEPSEEK_MODELS);
+    const config = {
+      providers: {
+        deepseek: {
+          baseUrl: 'https://api.deepseek.com/v1',
+          extraHeaders: { 'X-Test': '1' },
+          extraBody: { reasoning: true },
+        },
+      },
+    };
+    const p = createProvider({ providerId: 'deepseek', apiKey: 'sk', config, catalog });
+    const headers = (
+      p as unknown as { buildHeaders: () => Record<string, string> }
+    ).buildHeaders.call(p);
+    expect(headers['X-Test']).toBe('1');
+  });
+});
+
+describe('classifyFamily (re-exported from core)', () => {
+  it('classifies @anthropic-ai/sdk as anthropic', () => {
+    expect(classifyFamily('@anthropic-ai/sdk')).toBe('anthropic');
+  });
+  it('classifies openai npm as openai', () => {
+    expect(classifyFamily('openai')).toBe('openai');
+  });
+  it('classifies openai-compatible npm', () => {
+    expect(classifyFamily('openai-compatible')).toBe('openai-compatible');
+  });
+});