@soleri/core 9.0.3 → 9.2.0

package/src/llm/llm-client.test.ts

@@ -0,0 +1,345 @@
+import { describe, it, expect, vi } from 'vitest';
+import { LLMClient } from './llm-client.js';
+import { KeyPool } from './key-pool.js';
+import { LLMError } from './types.js';
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+function makeClient(opts?: {
+  openaiKeys?: string[];
+  anthropicKeys?: string[];
+}): LLMClient {
+  const openai = new KeyPool({ keys: opts?.openaiKeys ?? [] });
+  const anthropic = new KeyPool({ keys: opts?.anthropicKeys ?? [] });
+  return new LLMClient(openai, anthropic);
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+describe('LLMClient — colocated', () => {
+  describe('isAvailable', () => {
+    it('reports both unavailable with no keys', () => {
+      const client = makeClient();
+      expect(client.isAvailable()).toEqual({ openai: false, anthropic: false });
+    });
+
+    it('reports openai available when keys provided', () => {
+      const client = makeClient({ openaiKeys: ['sk-test'] });
+      expect(client.isAvailable()).toEqual({ openai: true, anthropic: false });
+    });
+
+    it('reports anthropic available when keys provided', () => {
+      const client = makeClient({ anthropicKeys: ['sk-ant-test'] });
+      expect(client.isAvailable()).toEqual({ openai: false, anthropic: true });
+    });
+
+    it('reports both available when both keys provided', () => {
+      const client = makeClient({ openaiKeys: ['sk-test'], anthropicKeys: ['sk-ant-test'] });
+      expect(client.isAvailable()).toEqual({ openai: true, anthropic: true });
+    });
+  });
+
+  describe('getRoutes', () => {
+    it('returns empty routes for client without agentId', () => {
+      const client = makeClient();
+      expect(client.getRoutes()).toEqual([]);
+    });
+  });
+
+  describe('complete — OpenAI error paths', () => {
+    it('throws LLMError when no OpenAI keys configured', async () => {
+      const client = makeClient();
+
+      await expect(
+        client.complete({
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          systemPrompt: 'test',
+          userPrompt: 'test',
+          caller: 'test',
+        }),
+      ).rejects.toThrow('OpenAI API key not configured');
+    });
+
+    it('throws when OpenAI API returns non-OK response', async () => {
+      const client = makeClient({ openaiKeys: ['sk-test'] });
+
+      // Mock fetch to return error
+      const originalFetch = globalThis.fetch;
+      globalThis.fetch = vi.fn().mockResolvedValue({
+        ok: false,
+        status: 401,
+        headers: new Headers(),
+        text: async () => 'Unauthorized',
+      });
+
+      try {
+        await expect(
+          client.complete({
+            provider: 'openai',
+            model: 'gpt-4o-mini',
+            systemPrompt: 'test',
+            userPrompt: 'test',
+            caller: 'test',
+          }),
+        ).rejects.toThrow('OpenAI API error');
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it('successfully calls OpenAI with mock fetch', async () => {
+      const client = makeClient({ openaiKeys: ['sk-test'] });
+
+      const originalFetch = globalThis.fetch;
+      globalThis.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        headers: new Headers(),
+        json: async () => ({
+          choices: [{ message: { content: 'Hello from mock!' } }],
+          usage: { prompt_tokens: 10, completion_tokens: 5 },
+        }),
+      });
+
+      try {
+        const result = await client.complete({
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          systemPrompt: 'You are helpful.',
+          userPrompt: 'Say hello.',
+          caller: 'test',
+          temperature: 0.5,
+          maxTokens: 100,
+        });
+
+        expect(result.text).toBe('Hello from mock!');
+        expect(result.model).toBe('gpt-4o-mini');
+        expect(result.provider).toBe('openai');
+        expect(result.inputTokens).toBe(10);
+        expect(result.outputTokens).toBe(5);
+        expect(result.durationMs).toBeGreaterThanOrEqual(0);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it('rotates key on 429 response when pool has multiple keys', async () => {
+      const openai = new KeyPool({ keys: ['sk-1', 'sk-2'] });
+      const anthropic = new KeyPool({ keys: [] });
+      const client = new LLMClient(openai, anthropic);
+
+      expect(openai.activeKeyIndex).toBe(0);
+
+      const originalFetch = globalThis.fetch;
+      let callCount = 0;
+      globalThis.fetch = vi.fn().mockImplementation(async () => {
+        callCount++;
+        if (callCount <= 3) {
+          return {
+            ok: false,
+            status: 429,
+            headers: new Headers(),
+            text: async () => 'Rate limited',
+          };
+        }
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers(),
+          json: async () => ({
+            choices: [{ message: { content: 'ok' } }],
+            usage: {},
+          }),
+        };
+      });
+
+      try {
+        // All 3 retry attempts will get 429, and the client retries retryable errors
+        await expect(
+          client.complete({
+            provider: 'openai',
+            model: 'gpt-4o-mini',
+            systemPrompt: 'test',
+            userPrompt: 'test',
+            caller: 'test',
+          }),
+        ).rejects.toThrow();
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it('parses rate limit headers and updates quota', async () => {
+      const openai = new KeyPool({ keys: ['sk-test'] });
+      const anthropic = new KeyPool({ keys: [] });
+      const client = new LLMClient(openai, anthropic);
+
+      const originalFetch = globalThis.fetch;
+      globalThis.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        headers: new Headers({
+          'x-ratelimit-remaining-requests': '42',
+        }),
+        json: async () => ({
+          choices: [{ message: { content: 'ok' } }],
+          usage: {},
+        }),
+      });
+
+      try {
+        await client.complete({
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          systemPrompt: 'test',
+          userPrompt: 'test',
+          caller: 'test',
+        });
+
+        const status = openai.getStatus();
+        expect(status.perKeyStatus[0].remainingQuota).toBe(42);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+  });
+
+  describe('complete — Anthropic error paths', () => {
+    it('throws LLMError when no Anthropic keys configured', async () => {
+      const client = makeClient();
+
+      await expect(
+        client.complete({
+          provider: 'anthropic',
+          model: 'claude-sonnet-4-20250514',
+          systemPrompt: 'test',
+          userPrompt: 'test',
+          caller: 'test',
+        }),
+      ).rejects.toThrow('Anthropic API key not configured');
+    });
+  });
+
+  describe('model routing', () => {
+    it('uses explicit provider when specified', async () => {
+      const client = makeClient({ openaiKeys: ['sk-test'] });
+
+      const originalFetch = globalThis.fetch;
+      let capturedBody: string = '';
+      globalThis.fetch = vi.fn().mockImplementation(async (_url: string, init: RequestInit) => {
+        capturedBody = init.body as string;
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers(),
+          json: async () => ({
+            choices: [{ message: { content: 'ok' } }],
+            usage: {},
+          }),
+        };
+      });
+
+      try {
+        await client.complete({
+          provider: 'openai',
+          model: 'gpt-4o',
+          systemPrompt: 'test',
+          userPrompt: 'test',
+          caller: 'test',
+        });
+
+        const parsed = JSON.parse(capturedBody);
+        expect(parsed.model).toBe('gpt-4o');
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it('uses default temperature of 0.3 when not specified', async () => {
+      const client = makeClient({ openaiKeys: ['sk-test'] });
+
+      const originalFetch = globalThis.fetch;
+      let capturedBody: string = '';
+      globalThis.fetch = vi.fn().mockImplementation(async (_url: string, init: RequestInit) => {
+        capturedBody = init.body as string;
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers(),
+          json: async () => ({
+            choices: [{ message: { content: 'ok' } }],
+            usage: {},
+          }),
+        };
+      });
+
+      try {
+        await client.complete({
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          systemPrompt: 'test',
+          userPrompt: 'test',
+          caller: 'test',
+        });
+
+        const parsed = JSON.parse(capturedBody);
+        expect(parsed.temperature).toBe(0.3);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+  });
+});
+
+describe('KeyPool — colocated', () => {
+  it('throws when getting active key from empty pool', () => {
+    const pool = new KeyPool({ keys: [] });
+    expect(() => pool.getActiveKey()).toThrow('no keys');
+  });
+
+  it('returns null from rotateOnError when all keys exhausted', () => {
+    const pool = new KeyPool({ keys: ['sk-1'] });
+    // Trip the breaker (threshold is 3 by default)
+    pool.rotateOnError();
+    pool.rotateOnError();
+    pool.rotateOnError();
+
+    expect(pool.exhausted).toBe(true);
+    // Further rotation returns null
+    const result = pool.rotateOnError();
+    expect(result).toBeNull();
+  });
+
+  it('does not preemptively rotate when quota is not set', () => {
+    const pool = new KeyPool({ keys: ['sk-1', 'sk-2'], preemptiveThreshold: 50 });
+    const rotated = pool.rotatePreemptive();
+    expect(rotated).toBe(false);
+    expect(pool.activeKeyIndex).toBe(0);
+  });
+});
+
+describe('LLMError — colocated', () => {
+  it('has correct name and prototype chain', () => {
+    const err = new LLMError('test error');
+    expect(err.name).toBe('LLMError');
+    expect(err).toBeInstanceOf(Error);
+    expect(err).toBeInstanceOf(LLMError);
+  });
+
+  it('defaults retryable to false', () => {
+    const err = new LLMError('test');
+    expect(err.retryable).toBe(false);
+    expect(err.statusCode).toBeUndefined();
+  });
+
+  it('accepts retryable and statusCode options', () => {
+    const err = new LLMError('rate limited', { retryable: true, statusCode: 429 });
+    expect(err.retryable).toBe(true);
+    expect(err.statusCode).toBe(429);
+  });
+});

package/src/llm/oauth-discovery.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
+
+// ─── Mocks (must be before import) ──────────────────────────────────
+
+vi.mock('node:child_process', () => ({
+  execFileSync: vi.fn(),
+}));
+
+vi.mock('node:fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(),
+}));
+
+vi.mock('node:os', () => ({
+  homedir: vi.fn(() => '/mock/home'),
+  platform: vi.fn(() => 'darwin'),
+}));
+
+import { execFileSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { platform } from 'node:os';
+import './oauth-discovery.js';
+
+// ─── discoverAnthropicToken ─────────────────────────────────────────
+
+describe('discoverAnthropicToken', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    // Reset module-level cache by re-importing would be ideal, but
+    // since the cache is module-scoped, we use resetModules + re-require.
+    // Instead we'll work with the cache: first test sets it, subsequent
+    // tests use the cached value. We use resetModules to clear between tests.
+    vi.resetModules();
+    process.env = { ...originalEnv };
+    delete process.env.ANTHROPIC_API_KEY;
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(readFileSync).mockReturnValue('{}');
+    vi.mocked(execFileSync).mockImplementation(() => { throw new Error('not found'); });
+    vi.mocked(platform).mockReturnValue('darwin');
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  // Since module cache persists across tests in the same file with vi.mock,
+  // we need to re-import after resetModules. Use a helper.
+  async function freshDiscover(): Promise<() => string | null> {
+    const mod = await import('./oauth-discovery.js');
+    return mod.discoverAnthropicToken;
+  }
+
+  it('should return env var when ANTHROPIC_API_KEY is set', async () => {
+    process.env.ANTHROPIC_API_KEY = 'sk-ant-test-key';
+    const discover = await freshDiscover();
+    expect(discover()).toBe('sk-ant-test-key');
+  });
+
+  it('should return token from credentials file with claudeAiOauth format', async () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(
+      JSON.stringify({ claudeAiOauth: { accessToken: 'oauth-token-123' } }),
+    );
+    const discover = await freshDiscover();
+    expect(discover()).toBe('oauth-token-123');
+  });
+
+  it('should return token from credentials file with direct accessToken', async () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(
+      JSON.stringify({ accessToken: 'direct-token' }),
+    );
+    const discover = await freshDiscover();
+    expect(discover()).toBe('direct-token');
+  });
+
+  it('should return token from credentials file with apiKey field', async () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(
+      JSON.stringify({ apiKey: 'api-key-field' }),
+    );
+    const discover = await freshDiscover();
+    expect(discover()).toBe('api-key-field');
+  });
+
+  it('should try macOS keychain on darwin platform', async () => {
+    vi.mocked(platform).mockReturnValue('darwin');
+    vi.mocked(execFileSync).mockReturnValue(
+      JSON.stringify({ claudeAiOauth: { accessToken: 'keychain-token' } }),
+    );
+    const discover = await freshDiscover();
+    expect(discover()).toBe('keychain-token');
+    expect(execFileSync).toHaveBeenCalledWith(
+      'security',
+      expect.arrayContaining(['find-generic-password']),
+      expect.any(Object),
+    );
+  });
+
+  it('should handle keychain returning non-JSON with regex fallback', async () => {
+    vi.mocked(platform).mockReturnValue('darwin');
+    vi.mocked(execFileSync).mockReturnValue(
+      '{ truncated "accessToken": "regex-token" garbage',
+    );
+    const discover = await freshDiscover();
+    expect(discover()).toBe('regex-token');
+  });
+
+  it('should try Linux keyring on linux platform', async () => {
+    vi.mocked(platform).mockReturnValue('linux');
+    vi.mocked(execFileSync).mockReturnValue(
+      JSON.stringify({ claudeAiOauth: { accessToken: 'linux-token' } }),
+    );
+    const discover = await freshDiscover();
+    expect(discover()).toBe('linux-token');
+    expect(execFileSync).toHaveBeenCalledWith(
+      'secret-tool',
+      expect.arrayContaining(['lookup', 'service', 'Claude Code']),
+      expect.any(Object),
+    );
+  });
+
+  it('should treat long raw string from Linux keyring as token', async () => {
+    vi.mocked(platform).mockReturnValue('linux');
+    vi.mocked(execFileSync).mockReturnValue('a-long-raw-token-string-that-is-definitely-over-twenty-chars');
+    const discover = await freshDiscover();
+    expect(discover()).toBe('a-long-raw-token-string-that-is-definitely-over-twenty-chars');
+  });
+
+  it('should return null when no token source is available', async () => {
+    const discover = await freshDiscover();
+    expect(discover()).toBeNull();
+  });
+
+  it('should return null on unsupported platform', async () => {
+    vi.mocked(platform).mockReturnValue('win32');
+    const discover = await freshDiscover();
+    expect(discover()).toBeNull();
+  });
+
+  it('should handle credentials file read errors gracefully', async () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockImplementation(() => { throw new Error('permission denied'); });
+    const discover = await freshDiscover();
+    expect(discover()).toBeNull();
+  });
+
+  it('should handle keychain errors gracefully', async () => {
+    vi.mocked(platform).mockReturnValue('darwin');
+    vi.mocked(execFileSync).mockImplementation(() => { throw new Error('no keychain entry'); });
+    const discover = await freshDiscover();
+    expect(discover()).toBeNull();
+  });
+
+  it('should handle empty keychain response', async () => {
+    vi.mocked(platform).mockReturnValue('darwin');
+    vi.mocked(execFileSync).mockReturnValue('   ');
+    const discover = await freshDiscover();
+    expect(discover()).toBeNull();
+  });
+
+  it('should prioritize env var over credentials file', async () => {
+    process.env.ANTHROPIC_API_KEY = 'env-key';
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(
+      JSON.stringify({ apiKey: 'file-key' }),
+    );
+    const discover = await freshDiscover();
+    expect(discover()).toBe('env-key');
+  });
+
+  it('should skip short raw strings from Linux keyring', async () => {
+    vi.mocked(platform).mockReturnValue('linux');
+    vi.mocked(execFileSync).mockReturnValue('short');
+    const discover = await freshDiscover();
+    expect(discover()).toBeNull();
+  });
+});