/**
* Tests for AI Provider abstraction
*
* @module @agentkits/memory/hooks/__tests__/ai-provider.test
*/
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import {
resolveAIProvider,
createClaudeCliProvider,
createOpenAIProvider,
createGeminiProvider,
type AIProviderConfig,
} from '../ai-provider.js';
describe('AI Provider', () => {
const originalEnv = { ...process.env };
beforeEach(() => {
// Clean env vars before each test
delete process.env.AGENTKITS_AI_PROVIDER;
delete process.env.AGENTKITS_AI_API_KEY;
delete process.env.AGENTKITS_AI_BASE_URL;
delete process.env.AGENTKITS_AI_MODEL;
});
afterEach(() => {
// Restore env
process.env = { ...originalEnv };
vi.restoreAllMocks();
});
// ===== resolveAIProvider =====
describe('resolveAIProvider', () => {
it('should default to claude-cli when no config and no env', () => {
const provider = resolveAIProvider();
expect(provider.name).toBe('claude-cli');
});
it('should use settings config provider', () => {
const config: AIProviderConfig = { provider: 'openai', apiKey: 'test-key' };
const provider = resolveAIProvider(config);
expect(provider.name).toBe('openai');
});
it('should use gemini provider from settings', () => {
const config: AIProviderConfig = { provider: 'gemini', apiKey: 'gemini-key' };
const provider = resolveAIProvider(config);
expect(provider.name).toBe('gemini');
});
it('should override settings with env var AGENTKITS_AI_PROVIDER', () => {
process.env.AGENTKITS_AI_PROVIDER = 'gemini';
process.env.AGENTKITS_AI_API_KEY = 'env-key';
const config: AIProviderConfig = { provider: 'openai', apiKey: 'settings-key' };
const provider = resolveAIProvider(config);
expect(provider.name).toBe('gemini');
});
it('should merge env API key with settings provider', () => {
process.env.AGENTKITS_AI_API_KEY = 'env-key';
const config: AIProviderConfig = { provider: 'openai' };
const provider = resolveAIProvider(config);
expect(provider.name).toBe('openai');
// Provider should be available because env key is set
expect(provider.isAvailable()).toBe(true);
});
it('should fall back to claude-cli for unknown provider', () => {
process.env.AGENTKITS_AI_PROVIDER = 'unknown-provider';
const provider = resolveAIProvider();
expect(provider.name).toBe('claude-cli');
});
it('should use env model override', () => {
process.env.AGENTKITS_AI_MODEL = 'custom-model';
const provider = resolveAIProvider();
expect(provider.name).toBe('claude-cli');
// Can't directly test model, but it shouldn't throw
});
});
// ===== Claude CLI Provider =====
describe('createClaudeCliProvider', () => {
it('should create a provider with name claude-cli', () => {
const provider = createClaudeCliProvider('haiku');
expect(provider.name).toBe('claude-cli');
});
it('should cache isAvailable result', () => {
const provider = createClaudeCliProvider('haiku');
// First call checks CLI, second should use cache
const first = provider.isAvailable();
const second = provider.isAvailable();
expect(first).toBe(second);
});
it('should return null from run when CLI is not available', async () => {
const provider = createClaudeCliProvider('nonexistent-model');
// execFileSync will throw for invalid claude args, provider catches and returns null
const result = await provider.run('test prompt', 'system', 5000);
// On CI or machines without claude CLI, this returns null
expect(result === null || typeof result === 'string').toBe(true);
});
});
// ===== OpenAI Provider =====
describe('createOpenAIProvider', () => {
it('should return unavailable when no API key', () => {
const provider = createOpenAIProvider('', 'https://api.openai.com/v1', 'gpt-4o-mini');
expect(provider.isAvailable()).toBe(false);
});
it('should return available when API key is set', () => {
const provider = createOpenAIProvider('sk-test', 'https://api.openai.com/v1', 'gpt-4o-mini');
expect(provider.isAvailable()).toBe(true);
expect(provider.name).toBe('openai');
});
it('should return null when fetch fails', async () => {
// Mock fetch to simulate network error
vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
const provider = createOpenAIProvider('sk-test', 'https://api.openai.com/v1', 'gpt-4o-mini');
const result = await provider.run('test', 'system', 5000);
expect(result).toBeNull();
});
it('should return null when response is not ok', async () => {
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
ok: false,
status: 401,
}));
const provider = createOpenAIProvider('sk-test', 'https://api.openai.com/v1', 'gpt-4o-mini');
const result = await provider.run('test', 'system', 5000);
expect(result).toBeNull();
});
it('should parse successful response correctly', async () => {
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
choices: [{ message: { content: '{"subtitle": "test"}' } }],
}),
}));
const provider = createOpenAIProvider('sk-test', 'https://api.openai.com/v1', 'gpt-4o-mini');
const result = await provider.run('test', 'system', 5000);
expect(result).toBe('{"subtitle": "test"}');
});
it('should send correct request format', async () => {
const mockFetch = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ choices: [{ message: { content: 'result' } }] }),
});
vi.stubGlobal('fetch', mockFetch);
const provider = createOpenAIProvider('sk-test', 'https://api.openai.com/v1', 'gpt-4o-mini');
await provider.run('my prompt', 'my system', 10000);
expect(mockFetch).toHaveBeenCalledTimes(1);
const [url, options] = mockFetch.mock.calls[0];
expect(url).toBe('https://api.openai.com/v1/chat/completions');
expect(options.method).toBe('POST');
expect(options.headers['Authorization']).toBe('Bearer sk-test');
const body = JSON.parse(options.body);
expect(body.model).toBe('gpt-4o-mini');
expect(body.messages).toEqual([
{ role: 'system', content: 'my system' },
{ role: 'user', content: 'my prompt' },
]);
expect(body.temperature).toBe(0.3);
expect(body.max_tokens).toBe(1024);
});
it('should strip trailing slash from base URL', async () => {
const mockFetch = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ choices: [{ message: { content: 'ok' } }] }),
});
vi.stubGlobal('fetch', mockFetch);
const provider = createOpenAIProvider('sk-test', 'https://openrouter.ai/api/v1/', 'model');
await provider.run('prompt', 'system', 5000);
const [url] = mockFetch.mock.calls[0];
expect(url).toBe('https://openrouter.ai/api/v1/chat/completions');
});
it('should return null when response has no choices', async () => {
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ choices: [] }),
}));
const provider = createOpenAIProvider('sk-test', 'https://api.openai.com/v1', 'gpt-4o-mini');
const result = await provider.run('test', 'system', 5000);
expect(result).toBeNull();
});
});
// ===== Gemini Provider =====
describe('createGeminiProvider', () => {
it('should return unavailable when no API key', () => {
const provider = createGeminiProvider('', 'gemini-2.0-flash');
expect(provider.isAvailable()).toBe(false);
});
it('should return available when API key is set', () => {
const provider = createGeminiProvider('test-key', 'gemini-2.0-flash');
expect(provider.isAvailable()).toBe(true);
expect(provider.name).toBe('gemini');
});
it('should return null when fetch fails', async () => {
vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
const provider = createGeminiProvider('test-key', 'gemini-2.0-flash');
const result = await provider.run('test', 'system', 5000);
expect(result).toBeNull();
});
it('should parse successful response correctly', async () => {
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
candidates: [{ content: { parts: [{ text: '{"result": "ok"}' }] } }],
}),
}));
const provider = createGeminiProvider('test-key', 'gemini-2.0-flash');
const result = await provider.run('test', 'system', 5000);
expect(result).toBe('{"result": "ok"}');
});
it('should send correct Gemini API format', async () => {
const mockFetch = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
candidates: [{ content: { parts: [{ text: 'result' }] } }],
}),
});
vi.stubGlobal('fetch', mockFetch);
const provider = createGeminiProvider('gemini-key', 'gemini-2.0-flash');
await provider.run('my prompt', 'my system', 10000);
expect(mockFetch).toHaveBeenCalledTimes(1);
const [url, options] = mockFetch.mock.calls[0];
expect(url).toContain('generativelanguage.googleapis.com');
expect(url).toContain('gemini-2.0-flash');
expect(url).toContain('key=gemini-key');
const body = JSON.parse(options.body);
expect(body.system_instruction).toEqual({ parts: [{ text: 'my system' }] });
expect(body.contents).toEqual([{ parts: [{ text: 'my prompt' }] }]);
expect(body.generationConfig.temperature).toBe(0.3);
expect(body.generationConfig.maxOutputTokens).toBe(1024);
});
it('should return null when response has no candidates', async () => {
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ candidates: [] }),
}));
const provider = createGeminiProvider('test-key', 'gemini-2.0-flash');
const result = await provider.run('test', 'system', 5000);
expect(result).toBeNull();
});
it('should return null on non-200 response', async () => {
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
ok: false,
status: 403,
}));
const provider = createGeminiProvider('test-key', 'gemini-2.0-flash');
const result = await provider.run('test', 'system', 5000);
expect(result).toBeNull();
});
});
});
