@bernierllc/ai-provider-openai 1.0.0

package/__tests__/error-handling.test.ts

@@ -0,0 +1,315 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { handleOpenAIError, isRetryableError, getRetryDelay } from '../src/utils/error-handling';
+import { AIProviderError } from '@bernierllc/ai-provider-core';
+import OpenAI from 'openai';
+
+describe('Error Handling', () => {
+  describe('handleOpenAIError()', () => {
+    it('should convert OpenAI APIError to AIProviderError', () => {
+      const apiError = new OpenAI.APIError(
+        400,
+        {
+          error: {
+            message: 'Invalid request',
+            type: 'invalid_request_error',
+            param: 'model',
+            code: 'invalid_model'
+          }
+        },
+        'Invalid request',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result).toBeInstanceOf(AIProviderError);
+      expect(result.message).toContain('OpenAI API Error');
+      expect(result.message).toContain('Invalid request');
+      expect(result.code).toBe('INVALID_REQUEST');
+      expect(result.provider).toBe('openai');
+    });
+
+    it('should map 401 status to AUTHENTICATION_ERROR', () => {
+      const apiError = new OpenAI.APIError(
+        401,
+        { error: { message: 'Invalid API key' } },
+        'Invalid API key',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('AUTHENTICATION_ERROR');
+    });
+
+    it('should map 403 status to PERMISSION_DENIED', () => {
+      const apiError = new OpenAI.APIError(
+        403,
+        { error: { message: 'Permission denied' } },
+        'Permission denied',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('PERMISSION_DENIED');
+    });
+
+    it('should map 404 status to NOT_FOUND', () => {
+      const apiError = new OpenAI.APIError(
+        404,
+        { error: { message: 'Model not found' } },
+        'Model not found',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('NOT_FOUND');
+    });
+
+    it('should map 429 status to RATE_LIMIT_ERROR', () => {
+      const apiError = new OpenAI.APIError(
+        429,
+        { error: { message: 'Rate limit exceeded' } },
+        'Rate limit exceeded',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('RATE_LIMIT_ERROR');
+    });
+
+    it('should map 500 status to SERVER_ERROR', () => {
+      const apiError = new OpenAI.APIError(
+        500,
+        { error: { message: 'Internal server error' } },
+        'Internal server error',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('SERVER_ERROR');
+    });
+
+    it('should map 502 status to SERVER_ERROR', () => {
+      const apiError = new OpenAI.APIError(
+        502,
+        { error: { message: 'Bad gateway' } },
+        'Bad gateway',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('SERVER_ERROR');
+    });
+
+    it('should map 503 status to SERVER_ERROR', () => {
+      const apiError = new OpenAI.APIError(
+        503,
+        { error: { message: 'Service unavailable' } },
+        'Service unavailable',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('SERVER_ERROR');
+    });
+
+    it('should map 504 status to TIMEOUT_ERROR', () => {
+      const apiError = new OpenAI.APIError(
+        504,
+        { error: { message: 'Gateway timeout' } },
+        'Gateway timeout',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('TIMEOUT_ERROR');
+    });
+
+    it('should map unknown status codes to UNKNOWN_ERROR', () => {
+      const apiError = new OpenAI.APIError(
+        418,
+        { error: { message: "I'm a teapot" } },
+        "I'm a teapot",
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('UNKNOWN_ERROR');
+    });
+
+    it('should handle APIError with undefined status', () => {
+      const apiError = new OpenAI.APIError(
+        undefined as any,
+        { error: { message: 'No status' } },
+        'No status',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.code).toBe('UNKNOWN_ERROR');
+    });
+
+    it('should handle regular Error objects', () => {
+      const error = new Error('Something went wrong');
+
+      const result = handleOpenAIError(error);
+
+      expect(result).toBeInstanceOf(AIProviderError);
+      expect(result.message).toBe('Something went wrong');
+      expect(result.code).toBe('UNKNOWN_ERROR');
+    });
+
+    it('should handle unknown error types', () => {
+      const result = handleOpenAIError('string error');
+
+      expect(result).toBeInstanceOf(AIProviderError);
+      expect(result.message).toBe('Unknown error occurred');
+      expect(result.code).toBe('UNKNOWN_ERROR');
+    });
+
+    it('should include error details in AIProviderError', () => {
+      const apiError = new OpenAI.APIError(
+        400,
+        {
+          error: {
+            message: 'Invalid request',
+            type: 'invalid_request_error',
+            param: 'model',
+            code: 'invalid_model'
+          }
+        },
+        'Invalid request',
+        {}
+      );
+
+      const result = handleOpenAIError(apiError);
+
+      expect(result.details).toBeDefined();
+      expect(result.details?.status).toBe(400);
+      // OpenAI.APIError type and code properties may not be available on all versions
+      // So we just verify the details object exists
+    });
+  });
+
+  describe('isRetryableError()', () => {
+    it('should identify RATE_LIMIT_ERROR as retryable', () => {
+      const error = new AIProviderError('Rate limit', 'RATE_LIMIT_ERROR', 'openai');
+      expect(isRetryableError(error)).toBe(true);
+    });
+
+    it('should identify SERVER_ERROR as retryable', () => {
+      const error = new AIProviderError('Server error', 'SERVER_ERROR', 'openai');
+      expect(isRetryableError(error)).toBe(true);
+    });
+
+    it('should identify TIMEOUT_ERROR as retryable', () => {
+      const error = new AIProviderError('Timeout', 'TIMEOUT_ERROR', 'openai');
+      expect(isRetryableError(error)).toBe(true);
+    });
+
+    it('should identify NETWORK_ERROR as retryable', () => {
+      const error = new AIProviderError('Network error', 'NETWORK_ERROR', 'openai');
+      expect(isRetryableError(error)).toBe(true);
+    });
+
+    it('should identify AUTHENTICATION_ERROR as not retryable', () => {
+      const error = new AIProviderError('Auth error', 'AUTHENTICATION_ERROR', 'openai');
+      expect(isRetryableError(error)).toBe(false);
+    });
+
+    it('should identify INVALID_REQUEST as not retryable', () => {
+      const error = new AIProviderError('Invalid', 'INVALID_REQUEST', 'openai');
+      expect(isRetryableError(error)).toBe(false);
+    });
+
+    it('should identify PERMISSION_DENIED as not retryable', () => {
+      const error = new AIProviderError('Denied', 'PERMISSION_DENIED', 'openai');
+      expect(isRetryableError(error)).toBe(false);
+    });
+  });
+
+  describe('getRetryDelay()', () => {
+    it('should return exponential backoff for rate limit errors', () => {
+      const error = new AIProviderError('Rate limit', 'RATE_LIMIT_ERROR', 'openai');
+
+      const delay1 = getRetryDelay(error, 1);
+      const delay2 = getRetryDelay(error, 2);
+      const delay3 = getRetryDelay(error, 3);
+
+      expect(delay1).toBe(2000); // 2^1 * 1000
+      expect(delay2).toBe(4000); // 2^2 * 1000
+      expect(delay3).toBe(8000); // 2^3 * 1000
+    });
+
+    it('should return exponential backoff for timeout errors', () => {
+      const error = new AIProviderError('Timeout', 'TIMEOUT_ERROR', 'openai');
+
+      const delay1 = getRetryDelay(error, 1);
+      const delay2 = getRetryDelay(error, 2);
+
+      expect(delay1).toBe(1000); // 2^1 * 500
+      expect(delay2).toBe(2000); // 2^2 * 500
+    });
+
+    it('should return exponential backoff for network errors', () => {
+      const error = new AIProviderError('Network', 'NETWORK_ERROR', 'openai');
+
+      const delay = getRetryDelay(error, 2);
+
+      expect(delay).toBe(2000); // 2^2 * 500
+    });
+
+    it('should cap rate limit retry delay at 60 seconds', () => {
+      const error = new AIProviderError('Rate limit', 'RATE_LIMIT_ERROR', 'openai');
+
+      const delay = getRetryDelay(error, 10);
+
+      expect(delay).toBe(60000);
+    });
+
+    it('should return exponential backoff for server errors', () => {
+      const error = new AIProviderError('Server error', 'SERVER_ERROR', 'openai');
+
+      const delay1 = getRetryDelay(error, 1);
+      const delay2 = getRetryDelay(error, 2);
+      const delay3 = getRetryDelay(error, 3);
+
+      expect(delay1).toBe(1000); // 2^1 * 500
+      expect(delay2).toBe(2000); // 2^2 * 500
+      expect(delay3).toBe(4000); // 2^3 * 500
+    });
+
+    it('should cap other retryable error delays at 30 seconds', () => {
+      const error = new AIProviderError('Timeout', 'TIMEOUT_ERROR', 'openai');
+
+      const delay = getRetryDelay(error, 10);
+
+      expect(delay).toBe(30000);
+    });
+
+    it('should return 0 for non-retryable errors', () => {
+      const error = new AIProviderError('Invalid', 'INVALID_REQUEST', 'openai');
+
+      const delay = getRetryDelay(error, 1);
+
+      expect(delay).toBe(0);
+    });
+  });
+});

package/__tests__/model-registry.test.ts

@@ -0,0 +1,270 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import {
+  OPENAI_MODELS,
+  getModelInfo,
+  getChatModels,
+  getEmbeddingModels,
+  getVisionModels,
+  supportsFunctionCalling
+} from '../src/models/model-registry';
+
+describe('Model Registry', () => {
+  describe('OPENAI_MODELS', () => {
+    it('should contain core chat models', () => {
+      const modelIds = OPENAI_MODELS.map(m => m.id);
+
+      expect(modelIds).toContain('gpt-4-turbo');
+      expect(modelIds).toContain('gpt-4');
+      expect(modelIds).toContain('gpt-3.5-turbo');
+      expect(modelIds).toContain('gpt-4-vision-preview');
+    });
+
+    it('should contain embedding models', () => {
+      const modelIds = OPENAI_MODELS.map(m => m.id);
+
+      expect(modelIds).toContain('text-embedding-3-small');
+      expect(modelIds).toContain('text-embedding-3-large');
+      expect(modelIds).toContain('text-embedding-ada-002');
+    });
+
+    it('should have correct pricing for gpt-4-turbo', () => {
+      const model = OPENAI_MODELS.find(m => m.id === 'gpt-4-turbo');
+
+      expect(model).toBeDefined();
+      expect(model!.pricing).toBeDefined();
+      expect(model!.pricing!.inputPricePerToken).toBe(0.01 / 1000);
+      expect(model!.pricing!.outputPricePerToken).toBe(0.03 / 1000);
+      expect(model!.pricing!.currency).toBe('USD');
+    });
+
+    it('should have correct pricing for gpt-3.5-turbo', () => {
+      const model = OPENAI_MODELS.find(m => m.id === 'gpt-3.5-turbo');
+
+      expect(model).toBeDefined();
+      expect(model!.pricing).toBeDefined();
+      expect(model!.pricing!.inputPricePerToken).toBe(0.0005 / 1000);
+      expect(model!.pricing!.outputPricePerToken).toBe(0.0015 / 1000);
+    });
+
+    it('should have correct context windows', () => {
+      const gpt4Turbo = OPENAI_MODELS.find(m => m.id === 'gpt-4-turbo');
+      const gpt4 = OPENAI_MODELS.find(m => m.id === 'gpt-4');
+      const gpt35 = OPENAI_MODELS.find(m => m.id === 'gpt-3.5-turbo');
+
+      expect(gpt4Turbo!.contextWindow).toBe(128000);
+      expect(gpt4!.contextWindow).toBe(8192);
+      expect(gpt35!.contextWindow).toBe(16385);
+    });
+
+    it('should have correct capabilities for chat models', () => {
+      const gpt4Turbo = OPENAI_MODELS.find(m => m.id === 'gpt-4-turbo');
+
+      expect(gpt4Turbo!.capabilities).toContain('chat');
+      expect(gpt4Turbo!.capabilities).toContain('completion');
+      expect(gpt4Turbo!.capabilities).toContain('function-calling');
+      expect(gpt4Turbo!.capabilities).toContain('vision');
+    });
+
+    it('should have correct capabilities for embedding models', () => {
+      const embedding = OPENAI_MODELS.find(m => m.id === 'text-embedding-3-small');
+
+      expect(embedding!.capabilities).toContain('embeddings');
+      expect(embedding!.capabilities).not.toContain('chat');
+    });
+  });
+
+  describe('getModelInfo()', () => {
+    it('should return model info for valid model ID', () => {
+      const model = getModelInfo('gpt-4-turbo');
+
+      expect(model).toBeDefined();
+      expect(model!.id).toBe('gpt-4-turbo');
+      expect(model!.name).toBe('GPT-4 Turbo');
+    });
+
+    it('should return undefined for unknown model ID', () => {
+      const model = getModelInfo('unknown-model');
+
+      expect(model).toBeUndefined();
+    });
+
+    it('should return embedding model info', () => {
+      const model = getModelInfo('text-embedding-3-small');
+
+      expect(model).toBeDefined();
+      expect(model!.capabilities).toContain('embeddings');
+    });
+  });
+
+  describe('getChatModels()', () => {
+    it('should return all chat-capable models', () => {
+      const chatModels = getChatModels();
+
+      expect(chatModels.length).toBeGreaterThan(0);
+
+      chatModels.forEach(model => {
+        const hasChat = model.capabilities.includes('chat') ||
+                       model.capabilities.includes('completion');
+        expect(hasChat).toBe(true);
+      });
+    });
+
+    it('should include GPT-4 models', () => {
+      const chatModels = getChatModels();
+      const modelIds = chatModels.map(m => m.id);
+
+      expect(modelIds).toContain('gpt-4-turbo');
+      expect(modelIds).toContain('gpt-4');
+      expect(modelIds).toContain('gpt-3.5-turbo');
+    });
+
+    it('should not include embedding models', () => {
+      const chatModels = getChatModels();
+      const hasEmbeddingOnly = chatModels.some(m =>
+        m.capabilities.includes('embeddings') &&
+        !m.capabilities.includes('chat') &&
+        !m.capabilities.includes('completion')
+      );
+
+      expect(hasEmbeddingOnly).toBe(false);
+    });
+  });
+
+  describe('getEmbeddingModels()', () => {
+    it('should return all embedding models', () => {
+      const embeddingModels = getEmbeddingModels();
+
+      expect(embeddingModels.length).toBeGreaterThan(0);
+
+      embeddingModels.forEach(model => {
+        expect(model.capabilities).toContain('embeddings');
+      });
+    });
+
+    it('should include all embedding model variants', () => {
+      const embeddingModels = getEmbeddingModels();
+      const modelIds = embeddingModels.map(m => m.id);
+
+      expect(modelIds).toContain('text-embedding-3-small');
+      expect(modelIds).toContain('text-embedding-3-large');
+      expect(modelIds).toContain('text-embedding-ada-002');
+    });
+
+    it('should not include chat models', () => {
+      const embeddingModels = getEmbeddingModels();
+      const hasChatOnly = embeddingModels.some(m =>
+        (m.capabilities.includes('chat') || m.capabilities.includes('completion')) &&
+        !m.capabilities.includes('embeddings')
+      );
+
+      expect(hasChatOnly).toBe(false);
+    });
+  });
+
+  describe('getVisionModels()', () => {
+    it('should return all vision-capable models', () => {
+      const visionModels = getVisionModels();
+
+      expect(visionModels.length).toBeGreaterThan(0);
+
+      visionModels.forEach(model => {
+        expect(model.capabilities).toContain('vision');
+      });
+    });
+
+    it('should include GPT-4 Vision models', () => {
+      const visionModels = getVisionModels();
+      const modelIds = visionModels.map(m => m.id);
+
+      expect(modelIds).toContain('gpt-4-vision-preview');
+      expect(modelIds).toContain('gpt-4-turbo');
+    });
+
+    it('should not include non-vision models', () => {
+      const visionModels = getVisionModels();
+      const modelIds = visionModels.map(m => m.id);
+
+      expect(modelIds).not.toContain('gpt-3.5-turbo');
+      expect(modelIds).not.toContain('text-embedding-3-small');
+    });
+  });
+
+  describe('supportsFunctionCalling()', () => {
+    it('should return true for models with function calling capability', () => {
+      expect(supportsFunctionCalling('gpt-4-turbo')).toBe(true);
+      expect(supportsFunctionCalling('gpt-4')).toBe(true);
+      expect(supportsFunctionCalling('gpt-3.5-turbo')).toBe(true);
+    });
+
+    it('should return false for embedding models', () => {
+      expect(supportsFunctionCalling('text-embedding-3-small')).toBe(false);
+      expect(supportsFunctionCalling('text-embedding-3-large')).toBe(false);
+    });
+
+    it('should return false for unknown models', () => {
+      expect(supportsFunctionCalling('unknown-model')).toBe(false);
+    });
+
+    it('should return false for vision-only models without function calling', () => {
+      const visionModel = OPENAI_MODELS.find(m =>
+        m.capabilities.includes('vision') &&
+        !m.capabilities.includes('function-calling')
+      );
+
+      if (visionModel) {
+        expect(supportsFunctionCalling(visionModel.id)).toBe(false);
+      }
+    });
+  });
+
+  describe('Model Completeness', () => {
+    it('should have all required fields for each model', () => {
+      OPENAI_MODELS.forEach(model => {
+        expect(model.id).toBeDefined();
+        expect(model.name).toBeDefined();
+        expect(model.contextWindow).toBeGreaterThan(0);
+        expect(model.maxOutputTokens).toBeGreaterThanOrEqual(0);
+        expect(model.capabilities).toBeDefined();
+        expect(model.capabilities.length).toBeGreaterThan(0);
+      });
+    });
+
+    it('should have pricing for all models', () => {
+      OPENAI_MODELS.forEach(model => {
+        if (model.capabilities.includes('chat') ||
+            model.capabilities.includes('completion') ||
+            model.capabilities.includes('embeddings')) {
+          expect(model.pricing).toBeDefined();
+          expect(model.pricing!.inputPricePerToken).toBeGreaterThan(0);
+          expect(model.pricing!.currency).toBe('USD');
+        }
+      });
+    });
+
+    it('should have valid capability combinations', () => {
+      OPENAI_MODELS.forEach(model => {
+        const capabilities = model.capabilities;
+
+        // Embedding models shouldn't have chat/completion
+        if (capabilities.includes('embeddings') && capabilities.length === 1) {
+          expect(capabilities).not.toContain('chat');
+          expect(capabilities).not.toContain('completion');
+        }
+
+        // Vision models should also have chat/completion
+        if (capabilities.includes('vision')) {
+          const hasChatOrCompletion = capabilities.includes('chat') ||
+                                     capabilities.includes('completion');
+          expect(hasChatOrCompletion).toBe(true);
+        }
+      });
+    });
+  });
+});