@bernierllc/ai-provider-openai 1.0.0

package/__tests__/openai-specific.test.ts

@@ -0,0 +1,333 @@
+/*
+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 { OpenAIProvider } from '../src/OpenAIProvider';
+import { OpenAIProviderConfig, OpenAIFunction } from '../src/types/openai-types';
+import OpenAI from 'openai';
+
+jest.mock('openai');
+
+describe('OpenAI-Specific Features', () => {
+  let provider: OpenAIProvider;
+  let mockClient: jest.Mocked<OpenAI>;
+
+  const config: OpenAIProviderConfig = {
+    providerName: 'openai',
+    apiKey: 'test-api-key',
+    defaultModel: 'gpt-4-turbo'
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockClient = {
+      chat: {
+        completions: {
+          create: jest.fn() as any
+        }
+      }
+    } as any;
+
+    (OpenAI as jest.MockedClass<typeof OpenAI>).mockImplementation(() => mockClient);
+
+    provider = new OpenAIProvider(config);
+  });
+
+  describe('completionWithFunctions()', () => {
+    it('should call OpenAI with function definitions', async () => {
+      const functions: OpenAIFunction[] = [
+        {
+          name: 'get_weather',
+          description: 'Get current weather',
+          parameters: {
+            type: 'object',
+            properties: {
+              location: { type: 'string', description: 'City name' },
+              unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+            },
+            required: ['location']
+          }
+        }
+      ];
+
+      const mockResponse = {
+        id: 'chatcmpl-123',
+        model: 'gpt-4-turbo',
+        created: Date.now(),
+        choices: [
+          {
+            message: {
+              role: 'assistant',
+              content: null,
+              function_call: {
+                name: 'get_weather',
+                arguments: '{"location":"San Francisco","unit":"celsius"}'
+              }
+            },
+            finish_reason: 'function_call'
+          }
+        ],
+        usage: {
+          prompt_tokens: 50,
+          completion_tokens: 20,
+          total_tokens: 70
+        }
+      };
+
+      mockClient.chat.completions.create.mockResolvedValue(mockResponse as any);
+
+      const result = await provider.completionWithFunctions({
+        messages: [{ role: 'user', content: 'What is the weather in San Francisco?' }],
+        functions
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.metadata?.functionCall).toEqual({
+        name: 'get_weather',
+        arguments: '{"location":"San Francisco","unit":"celsius"}'
+      });
+      expect(result.finishReason).toBe('function_call');
+
+      expect(mockClient.chat.completions.create).toHaveBeenCalledWith({
+        model: 'gpt-4-turbo',
+        messages: [{ role: 'user', content: 'What is the weather in San Francisco?' }],
+        functions,
+        function_call: 'auto'
+      });
+    });
+
+    it('should handle regular text response when function not needed', async () => {
+      const functions: OpenAIFunction[] = [
+        {
+          name: 'get_weather',
+          description: 'Get current weather',
+          parameters: {
+            type: 'object',
+            properties: { location: { type: 'string' } },
+            required: ['location']
+          }
+        }
+      ];
+
+      const mockResponse = {
+        choices: [
+          {
+            message: {
+              role: 'assistant',
+              content: 'I need more information to check the weather.',
+              function_call: undefined
+            },
+            finish_reason: 'stop'
+          }
+        ],
+        usage: {
+          prompt_tokens: 30,
+          completion_tokens: 10,
+          total_tokens: 40
+        }
+      };
+
+      mockClient.chat.completions.create.mockResolvedValue(mockResponse as any);
+
+      const result = await provider.completionWithFunctions({
+        messages: [{ role: 'user', content: 'Hello' }],
+        functions
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe('I need more information to check the weather.');
+      expect(result.finishReason).toBe('stop');
+      expect(result.metadata?.functionCall).toBeUndefined();
+    });
+
+    it('should handle multiple function definitions', async () => {
+      const functions: OpenAIFunction[] = [
+        {
+          name: 'get_weather',
+          description: 'Get weather',
+          parameters: {
+            type: 'object',
+            properties: { location: { type: 'string' } },
+            required: ['location']
+          }
+        },
+        {
+          name: 'get_time',
+          description: 'Get current time',
+          parameters: {
+            type: 'object',
+            properties: { timezone: { type: 'string' } }
+          }
+        }
+      ];
+
+      mockClient.chat.completions.create.mockResolvedValue({
+        choices: [
+          {
+            message: {
+              role: 'assistant',
+              content: null,
+              function_call: { name: 'get_time', arguments: '{"timezone":"PST"}' }
+            },
+            finish_reason: 'function_call'
+          }
+        ]
+      } as any);
+
+      const result = await provider.completionWithFunctions({
+        messages: [{ role: 'user', content: 'What time is it in PST?' }],
+        functions
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.metadata?.functionCall?.name).toBe('get_time');
+    });
+
+    it('should handle API errors', async () => {
+      const functions: OpenAIFunction[] = [
+        {
+          name: 'test_function',
+          description: 'Test',
+          parameters: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ];
+
+      mockClient.chat.completions.create.mockRejectedValue(new Error('API Error'));
+
+      const result = await provider.completionWithFunctions({
+        messages: [{ role: 'user', content: 'Test' }],
+        functions
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('analyzeImage()', () => {
+    it('should analyze image with GPT-4 Vision', async () => {
+      const mockResponse = {
+        model: 'gpt-4-vision-preview',
+        choices: [
+          {
+            message: {
+              role: 'assistant',
+              content: 'The image shows a beautiful sunset over the ocean with orange and purple hues.'
+            },
+            finish_reason: 'stop'
+          }
+        ],
+        usage: {
+          prompt_tokens: 100,
+          completion_tokens: 50,
+          total_tokens: 150
+        }
+      };
+
+      mockClient.chat.completions.create.mockResolvedValue(mockResponse as any);
+
+      const result = await provider.analyzeImage(
+        'https://example.com/sunset.jpg',
+        'Describe this image in detail'
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.content).toContain('sunset');
+      expect(result.usage?.totalTokens).toBe(150);
+      expect(result.model).toBe('gpt-4-vision-preview');
+
+      expect(mockClient.chat.completions.create).toHaveBeenCalledWith({
+        model: 'gpt-4-vision-preview',
+        messages: [
+          {
+            role: 'user',
+            content: [
+              { type: 'text', text: 'Describe this image in detail' },
+              { type: 'image_url', image_url: { url: 'https://example.com/sunset.jpg' } }
+            ]
+          }
+        ],
+        max_tokens: 1000
+      });
+    });
+
+    it('should support custom model', async () => {
+      mockClient.chat.completions.create.mockResolvedValue({
+        model: 'gpt-4-turbo',
+        choices: [{ message: { content: 'Analysis result' }, finish_reason: 'stop' }]
+      } as any);
+
+      await provider.analyzeImage(
+        'https://example.com/image.jpg',
+        'Analyze this',
+        'gpt-4-turbo'
+      );
+
+      expect(mockClient.chat.completions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: 'gpt-4-turbo'
+        })
+      );
+    });
+
+    it('should handle empty or null content', async () => {
+      mockClient.chat.completions.create.mockResolvedValue({
+        choices: [{ message: { content: null }, finish_reason: 'stop' }]
+      } as any);
+
+      const result = await provider.analyzeImage(
+        'https://example.com/image.jpg',
+        'Describe this'
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe('');
+    });
+
+    it('should handle API errors', async () => {
+      const apiError = new OpenAI.APIError(
+        400,
+        { error: { message: 'Invalid image URL' } },
+        'Invalid image URL',
+        {}
+      );
+
+      mockClient.chat.completions.create.mockRejectedValue(apiError);
+
+      const result = await provider.analyzeImage(
+        'invalid-url',
+        'Describe this'
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('OpenAI API Error');
+    });
+
+    it('should handle rate limiting', async () => {
+      const rateLimitError = new OpenAI.APIError(
+        429,
+        { error: { message: 'Rate limit exceeded' } },
+        'Rate limit exceeded',
+        {}
+      );
+
+      mockClient.chat.completions.create.mockRejectedValue(rateLimitError);
+
+      const result = await provider.analyzeImage(
+        'https://example.com/image.jpg',
+        'Describe'
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+});

package/dist/OpenAIProvider.d.ts

@@ -0,0 +1,22 @@
+import { AIProvider, CompletionRequest, CompletionResponse, StreamChunk, EmbeddingRequest, EmbeddingResponse, ModerationResponse, ModelInfo, HealthStatus, CostEstimate } from '@bernierllc/ai-provider-core';
+import { OpenAIProviderConfig, OpenAIFunction } from './types/openai-types';
+export declare class OpenAIProvider extends AIProvider {
+    private client;
+    private models;
+    constructor(config: OpenAIProviderConfig);
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    streamComplete(request: CompletionRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    generateEmbeddings(request: EmbeddingRequest): Promise<EmbeddingResponse>;
+    moderate(content: string): Promise<ModerationResponse>;
+    getAvailableModels(): Promise<ModelInfo[]>;
+    checkHealth(): Promise<HealthStatus>;
+    completionWithFunctions(request: CompletionRequest & {
+        functions: OpenAIFunction[];
+    }): Promise<CompletionResponse>;
+    analyzeImage(imageUrl: string, prompt: string, model?: string): Promise<CompletionResponse>;
+    estimateCost(request: CompletionRequest): CostEstimate;
+    private initializeModels;
+    private mapOpenAIModel;
+    private getModelPricing;
+}
+//# sourceMappingURL=OpenAIProvider.d.ts.map

package/dist/OpenAIProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAIProvider.d.ts","sourceRoot":"","sources":["../src/OpenAIProvider.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACb,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAQ5E,qBAAa,cAAe,SAAQ,UAAU;IAC5C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAqC;gBAEvC,MAAM,EAAE,oBAAoB;IAqBlC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8DhE,cAAc,CACnB,OAAO,EAAE,iBAAiB,GACzB,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,OAAO,CAAC;IA6CvC,kBAAkB,CACtB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,CAAC;IA8BvB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA2BtD,kBAAkB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAmB1C,WAAW,IAAI,OAAO,CAAC,YAAY,CAAC;IA+BpC,uBAAuB,CAC3B,OAAO,EAAE,iBAAiB,GAAG;QAAE,SAAS,EAAE,cAAc,EAAE,CAAA;KAAE,GAC3D,OAAO,CAAC,kBAAkB,CAAC;IA6CxB,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAA+B,GACrC,OAAO,CAAC,kBAAkB,CAAC;IAkD9B,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,YAAY;IAyBtD,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,cAAc;IAetB,OAAO,CAAC,eAAe;CAexB"}

package/dist/OpenAIProvider.js

@@ -0,0 +1,320 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const ai_provider_core_1 = require("@bernierllc/ai-provider-core");
+const openai_1 = __importDefault(require("openai"));
+const model_registry_1 = require("./models/model-registry");
+const error_handling_1 = require("./utils/error-handling");
+class OpenAIProvider extends ai_provider_core_1.AIProvider {
+    constructor(config) {
+        super(config);
+        this.models = new Map();
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+            organization: config.organizationId,
+            baseURL: config.baseURL,
+            timeout: config.timeout || 60000,
+            maxRetries: config.maxRetries || 3
+        });
+        this.initializeModels();
+    }
+    async complete(request) {
+        const validation = this.validateRequest(request);
+        if (!validation.isValid) {
+            return {
+                success: false,
+                error: validation.errors.join(', ')
+            };
+        }
+        try {
+            const completion = await this.client.chat.completions.create({
+                model: request.model || this.config.defaultModel || 'gpt-4-turbo',
+                messages: request.messages.map(msg => ({
+                    role: msg.role,
+                    content: msg.content,
+                    name: msg.name
+                })),
+                max_tokens: request.maxTokens,
+                temperature: request.temperature,
+                top_p: request.topP,
+                frequency_penalty: request.frequencyPenalty,
+                presence_penalty: request.presencePenalty,
+                stop: request.stop,
+                user: request.user
+            });
+            const choice = completion.choices[0];
+            const finishReason = choice.finish_reason === 'tool_calls' || choice.finish_reason === 'function_call'
+                ? 'function_call'
+                : choice.finish_reason;
+            return {
+                success: true,
+                content: choice.message.content || '',
+                finishReason,
+                usage: completion.usage ? {
+                    promptTokens: completion.usage.prompt_tokens,
+                    completionTokens: completion.usage.completion_tokens,
+                    totalTokens: completion.usage.total_tokens
+                } : undefined,
+                model: completion.model,
+                metadata: {
+                    id: completion.id,
+                    created: completion.created,
+                    systemFingerprint: completion.system_fingerprint
+                }
+            };
+        }
+        catch (error) {
+            const aiError = (0, error_handling_1.handleOpenAIError)(error);
+            return {
+                success: false,
+                error: aiError.message
+            };
+        }
+    }
+    async *streamComplete(request) {
+        const validation = this.validateRequest(request);
+        if (!validation.isValid) {
+            throw new Error(validation.errors.join(', '));
+        }
+        try {
+            const stream = await this.client.chat.completions.create({
+                model: request.model || this.config.defaultModel || 'gpt-4-turbo',
+                messages: request.messages.map(msg => ({
+                    role: msg.role,
+                    content: msg.content
+                })),
+                max_tokens: request.maxTokens,
+                temperature: request.temperature,
+                stream: true
+            });
+            for await (const chunk of stream) {
+                const delta = chunk.choices[0]?.delta?.content || '';
+                const rawFinishReason = chunk.choices[0]?.finish_reason;
+                const finishReason = (rawFinishReason === 'stop' || rawFinishReason === 'length' || rawFinishReason === 'content_filter')
+                    ? rawFinishReason
+                    : undefined;
+                yield {
+                    delta,
+                    finishReason,
+                    usage: chunk.usage ? {
+                        promptTokens: chunk.usage.prompt_tokens,
+                        completionTokens: chunk.usage.completion_tokens,
+                        totalTokens: chunk.usage.total_tokens
+                    } : undefined
+                };
+            }
+        }
+        catch (error) {
+            throw (0, error_handling_1.handleOpenAIError)(error);
+        }
+    }
+    async generateEmbeddings(request) {
+        try {
+            const response = await this.client.embeddings.create({
+                model: request.model || 'text-embedding-3-small',
+                input: request.input,
+                user: request.user
+            });
+            return {
+                success: true,
+                embeddings: response.data.map(item => item.embedding),
+                usage: {
+                    promptTokens: response.usage.prompt_tokens,
+                    completionTokens: 0,
+                    totalTokens: response.usage.total_tokens
+                },
+                model: response.model
+            };
+        }
+        catch (error) {
+            const aiError = (0, error_handling_1.handleOpenAIError)(error);
+            return {
+                success: false,
+                error: aiError.message
+            };
+        }
+    }
+    async moderate(content) {
+        try {
+            const response = await this.client.moderations.create({
+                input: content
+            });
+            const result = response.results[0];
+            return {
+                success: true,
+                flagged: result.flagged,
+                categories: result.categories,
+                categoryScores: result.category_scores
+            };
+        }
+        catch (error) {
+            const aiError = (0, error_handling_1.handleOpenAIError)(error);
+            return {
+                success: false,
+                flagged: false,
+                error: aiError.message
+            };
+        }
+    }
+    async getAvailableModels() {
+        try {
+            const response = await this.client.models.list();
+            return response.data
+                .filter(model => model.id.startsWith('gpt-') ||
+                model.id.startsWith('text-embedding'))
+                .map(model => this.mapOpenAIModel(model));
+        }
+        catch {
+            return Array.from(this.models.values());
+        }
+    }
+    async checkHealth() {
+        const startTime = Date.now();
+        try {
+            await this.client.models.retrieve('gpt-3.5-turbo');
+            return {
+                status: 'healthy',
+                latency: Date.now() - startTime,
+                lastChecked: new Date()
+            };
+        }
+        catch (error) {
+            return {
+                status: 'unavailable',
+                latency: Date.now() - startTime,
+                lastChecked: new Date(),
+                details: {
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                }
+            };
+        }
+    }
+    async completionWithFunctions(request) {
+        try {
+            const completion = await this.client.chat.completions.create({
+                model: request.model || 'gpt-4-turbo',
+                messages: request.messages.map(msg => ({
+                    role: msg.role,
+                    content: msg.content
+                })),
+                functions: request.functions,
+                function_call: 'auto'
+            });
+            const choice = completion.choices[0];
+            const finishReason = choice.finish_reason === 'tool_calls' || choice.finish_reason === 'function_call'
+                ? 'function_call'
+                : choice.finish_reason;
+            return {
+                success: true,
+                content: choice.message.content || '',
+                finishReason,
+                usage: completion.usage ? {
+                    promptTokens: completion.usage.prompt_tokens,
+                    completionTokens: completion.usage.completion_tokens,
+                    totalTokens: completion.usage.total_tokens
+                } : undefined,
+                model: completion.model,
+                metadata: {
+                    functionCall: choice.message.function_call
+                }
+            };
+        }
+        catch (error) {
+            const aiError = (0, error_handling_1.handleOpenAIError)(error);
+            return {
+                success: false,
+                error: aiError.message
+            };
+        }
+    }
+    async analyzeImage(imageUrl, prompt, model = 'gpt-4-vision-preview') {
+        try {
+            const completion = await this.client.chat.completions.create({
+                model,
+                messages: [
+                    {
+                        role: 'user',
+                        content: [
+                            { type: 'text', text: prompt },
+                            { type: 'image_url', image_url: { url: imageUrl } }
+                        ]
+                    }
+                ],
+                max_tokens: 1000
+            });
+            const choice = completion.choices[0];
+            const finishReason = choice.finish_reason === 'tool_calls' || choice.finish_reason === 'function_call'
+                ? 'function_call'
+                : choice.finish_reason;
+            return {
+                success: true,
+                content: choice.message.content || '',
+                finishReason,
+                usage: completion.usage ? {
+                    promptTokens: completion.usage.prompt_tokens,
+                    completionTokens: completion.usage.completion_tokens,
+                    totalTokens: completion.usage.total_tokens
+                } : undefined,
+                model: completion.model
+            };
+        }
+        catch (error) {
+            const aiError = (0, error_handling_1.handleOpenAIError)(error);
+            return {
+                success: false,
+                error: aiError.message
+            };
+        }
+    }
+    estimateCost(request) {
+        const model = request.model || this.config.defaultModel || 'gpt-4-turbo';
+        const pricing = this.getModelPricing(model);
+        const inputTokens = this.estimateTokens(request.messages.map(m => m.content).join(' '));
+        const outputTokens = request.maxTokens || 1000;
+        const inputCost = (inputTokens / 1000) * pricing.inputPrice;
+        const outputCost = (outputTokens / 1000) * pricing.outputPrice;
+        return {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+            estimatedCostUSD: inputCost + outputCost,
+            currency: 'USD'
+        };
+    }
+    initializeModels() {
+        model_registry_1.OPENAI_MODELS.forEach(model => {
+            this.models.set(model.id, model);
+        });
+    }
+    mapOpenAIModel(model) {
+        const cached = this.models.get(model.id);
+        if (cached) {
+            return cached;
+        }
+        return {
+            id: model.id,
+            name: model.id,
+            contextWindow: 8192,
+            maxOutputTokens: 4096,
+            capabilities: ['chat']
+        };
+    }
+    getModelPricing(model) {
+        const modelInfo = this.models.get(model);
+        if (modelInfo?.pricing) {
+            return {
+                inputPrice: modelInfo.pricing.inputPricePerToken * 1000,
+                outputPrice: modelInfo.pricing.outputPricePerToken * 1000
+            };
+        }
+        return {
+            inputPrice: 0.0005,
+            outputPrice: 0.0015
+        };
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;
+//# sourceMappingURL=OpenAIProvider.js.map