@bernierllc/ai-provider-openai 1.0.0

package/src/OpenAIProvider.ts

@@ -0,0 +1,435 @@
+/*
+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 {
+  AIProvider,
+  CompletionRequest,
+  CompletionResponse,
+  StreamChunk,
+  EmbeddingRequest,
+  EmbeddingResponse,
+  ModerationResponse,
+  ModelInfo,
+  HealthStatus,
+  CostEstimate
+} from '@bernierllc/ai-provider-core';
+import OpenAI from 'openai';
+import { OpenAIProviderConfig, OpenAIFunction } from './types/openai-types';
+import { OPENAI_MODELS } from './models/model-registry';
+import { handleOpenAIError } from './utils/error-handling';
+
+/**
+ * OpenAI Provider Implementation
+ * Implements the unified AI provider interface for OpenAI's API
+ */
+export class OpenAIProvider extends AIProvider {
+  private client: OpenAI;
+  private models: Map<string, ModelInfo> = new Map();
+
+  constructor(config: OpenAIProviderConfig) {
+    super(config);
+
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      organization: config.organizationId,
+      baseURL: config.baseURL,
+      timeout: config.timeout || 60000,
+      maxRetries: config.maxRetries || 3
+    });
+
+    this.initializeModels();
+  }
+
+  // ============================================
+  // CORE OPERATIONS (REQUIRED)
+  // ============================================
+
+  /**
+   * Generate text completion using OpenAI API
+   */
+  async complete(request: CompletionRequest): Promise<CompletionResponse> {
+    // Validate 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 as 'system' | 'user' | 'assistant',
+          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];
+
+      // Map OpenAI's finish_reason to base interface types
+      const finishReason = choice.finish_reason === 'tool_calls' || choice.finish_reason === 'function_call'
+        ? 'function_call' as const
+        : choice.finish_reason as 'stop' | 'length' | 'content_filter' | undefined;
+
+      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 = handleOpenAIError(error);
+      return {
+        success: false,
+        error: aiError.message
+      };
+    }
+  }
+
+  /**
+   * Generate streaming text completion
+   */
+  async *streamComplete(
+    request: CompletionRequest
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    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 as 'system' | 'user' | 'assistant',
+          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;
+
+        // Map finish_reason for streaming (StreamChunk doesn't include function_call)
+        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 handleOpenAIError(error);
+    }
+  }
+
+  /**
+   * Generate embeddings using OpenAI embeddings API
+   */
+  async generateEmbeddings(
+    request: EmbeddingRequest
+  ): Promise<EmbeddingResponse> {
+    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 = handleOpenAIError(error);
+      return {
+        success: false,
+        error: aiError.message
+      };
+    }
+  }
+
+  /**
+   * Check content moderation using OpenAI moderation API
+   */
+  async moderate(content: string): Promise<ModerationResponse> {
+    try {
+      const response = await this.client.moderations.create({
+        input: content
+      });
+
+      const result = response.results[0];
+
+      return {
+        success: true,
+        flagged: result.flagged,
+        categories: result.categories as unknown as Record<string, boolean>,
+        categoryScores: result.category_scores as unknown as Record<string, number>
+      };
+    } catch (error) {
+      const aiError = handleOpenAIError(error);
+      return {
+        success: false,
+        flagged: false,
+        error: aiError.message
+      };
+    }
+  }
+
+  /**
+   * Get available OpenAI models
+   */
+  async getAvailableModels(): Promise<ModelInfo[]> {
+    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 cached models if API fails
+      return Array.from(this.models.values());
+    }
+  }
+
+  /**
+   * Check OpenAI API health
+   */
+  async checkHealth(): Promise<HealthStatus> {
+    const startTime = Date.now();
+
+    try {
+      // Simple test request to verify API connectivity
+      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'
+        }
+      };
+    }
+  }
+
+  // ============================================
+  // OPENAI-SPECIFIC FEATURES
+  // ============================================
+
+  /**
+   * Chat completion with function calling
+   */
+  async completionWithFunctions(
+    request: CompletionRequest & { functions: OpenAIFunction[] }
+  ): Promise<CompletionResponse> {
+    try {
+      const completion = await this.client.chat.completions.create({
+        model: request.model || 'gpt-4-turbo',
+        messages: request.messages.map(msg => ({
+          role: msg.role as 'system' | 'user' | 'assistant',
+          content: msg.content
+        })),
+        functions: request.functions,
+        function_call: 'auto'
+      });
+
+      const choice = completion.choices[0];
+
+      // Map finish_reason to base types
+      const finishReason = choice.finish_reason === 'tool_calls' || choice.finish_reason === 'function_call'
+        ? 'function_call' as const
+        : choice.finish_reason as 'stop' | 'length' | 'content_filter' | undefined;
+
+      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 = handleOpenAIError(error);
+      return {
+        success: false,
+        error: aiError.message
+      };
+    }
+  }
+
+  /**
+   * Vision capabilities (GPT-4 Vision)
+   */
+  async analyzeImage(
+    imageUrl: string,
+    prompt: string,
+    model: string = 'gpt-4-vision-preview'
+  ): Promise<CompletionResponse> {
+    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];
+
+      // Map finish_reason to base types
+      const finishReason = choice.finish_reason === 'tool_calls' || choice.finish_reason === 'function_call'
+        ? 'function_call' as const
+        : choice.finish_reason as 'stop' | 'length' | 'content_filter' | undefined;
+
+      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 = handleOpenAIError(error);
+      return {
+        success: false,
+        error: aiError.message
+      };
+    }
+  }
+
+  // ============================================
+  // COST ESTIMATION (OVERRIDE)
+  // ============================================
+
+  /**
+   * Estimate cost using OpenAI pricing
+   */
+  estimateCost(request: CompletionRequest): CostEstimate {
+    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'
+    };
+  }
+
+  // ============================================
+  // PRIVATE METHODS
+  // ============================================
+
+  private initializeModels() {
+    OPENAI_MODELS.forEach(model => {
+      this.models.set(model.id, model);
+    });
+  }
+
+  private mapOpenAIModel(model: OpenAI.Model): ModelInfo {
+    const cached = this.models.get(model.id);
+    if (cached) {
+      return cached;
+    }
+
+    return {
+      id: model.id,
+      name: model.id,
+      contextWindow: 8192, // Default
+      maxOutputTokens: 4096, // Default
+      capabilities: ['chat']
+    };
+  }
+
+  private getModelPricing(model: string): { inputPrice: number; outputPrice: number } {
+    const modelInfo = this.models.get(model);
+    if (modelInfo?.pricing) {
+      return {
+        inputPrice: modelInfo.pricing.inputPricePerToken * 1000,
+        outputPrice: modelInfo.pricing.outputPricePerToken * 1000
+      };
+    }
+
+    // Default pricing (gpt-3.5-turbo)
+    return {
+      inputPrice: 0.0005,
+      outputPrice: 0.0015
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+/*
+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.
+*/
+
+export { OpenAIProvider } from './OpenAIProvider';
+export * from './types/openai-types';
+export * from './models/model-registry';
+export * from './utils/error-handling';

package/src/models/model-registry.ts

@@ -0,0 +1,178 @@
+/*
+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 { ModelInfo } from '@bernierllc/ai-provider-core';
+
+/**
+ * OpenAI Model Registry
+ * Contains information about all available OpenAI models
+ */
+export const OPENAI_MODELS: ModelInfo[] = [
+  {
+    id: 'gpt-4-turbo',
+    name: 'GPT-4 Turbo',
+    contextWindow: 128000,
+    maxOutputTokens: 4096,
+    pricing: {
+      inputPricePerToken: 0.01 / 1000,
+      outputPricePerToken: 0.03 / 1000,
+      currency: 'USD'
+    },
+    capabilities: ['chat', 'completion', 'function-calling', 'vision']
+  },
+  {
+    id: 'gpt-4-turbo-preview',
+    name: 'GPT-4 Turbo Preview',
+    contextWindow: 128000,
+    maxOutputTokens: 4096,
+    pricing: {
+      inputPricePerToken: 0.01 / 1000,
+      outputPricePerToken: 0.03 / 1000,
+      currency: 'USD'
+    },
+    capabilities: ['chat', 'completion', 'function-calling']
+  },
+  {
+    id: 'gpt-4',
+    name: 'GPT-4',
+    contextWindow: 8192,
+    maxOutputTokens: 8192,
+    pricing: {
+      inputPricePerToken: 0.03 / 1000,
+      outputPricePerToken: 0.06 / 1000,
+      currency: 'USD'
+    },
+    capabilities: ['chat', 'completion', 'function-calling']
+  },
+  {
+    id: 'gpt-4-32k',
+    name: 'GPT-4 32K',
+    contextWindow: 32768,
+    maxOutputTokens: 32768,
+    pricing: {
+      inputPricePerToken: 0.06 / 1000,
+      outputPricePerToken: 0.12 / 1000,
+      currency: 'USD'
+    },
+    capabilities: ['chat', 'completion', 'function-calling']
+  },
+  {
+    id: 'gpt-3.5-turbo',
+    name: 'GPT-3.5 Turbo',
+    contextWindow: 16385,
+    maxOutputTokens: 4096,
+    pricing: {
+      inputPricePerToken: 0.0005 / 1000,
+      outputPricePerToken: 0.0015 / 1000,
+      currency: 'USD'
+    },
+    capabilities: ['chat', 'completion', 'function-calling']
+  },
+  {
+    id: 'gpt-3.5-turbo-16k',
+    name: 'GPT-3.5 Turbo 16K',
+    contextWindow: 16385,
+    maxOutputTokens: 16385,
+    pricing: {
+      inputPricePerToken: 0.003 / 1000,
+      outputPricePerToken: 0.004 / 1000,
+      currency: 'USD'
+    },
+    capabilities: ['chat', 'completion', 'function-calling']
+  },
+  {
+    id: 'gpt-4-vision-preview',
+    name: 'GPT-4 Vision Preview',
+    contextWindow: 128000,
+    maxOutputTokens: 4096,
+    pricing: {
+      inputPricePerToken: 0.01 / 1000,
+      outputPricePerToken: 0.03 / 1000,
+      currency: 'USD'
+    },
+    capabilities: ['chat', 'completion', 'vision']
+  },
+  {
+    id: 'text-embedding-3-small',
+    name: 'Text Embedding 3 Small',
+    contextWindow: 8191,
+    maxOutputTokens: 0,
+    pricing: {
+      inputPricePerToken: 0.00002 / 1000,
+      outputPricePerToken: 0,
+      currency: 'USD'
+    },
+    capabilities: ['embeddings']
+  },
+  {
+    id: 'text-embedding-3-large',
+    name: 'Text Embedding 3 Large',
+    contextWindow: 8191,
+    maxOutputTokens: 0,
+    pricing: {
+      inputPricePerToken: 0.00013 / 1000,
+      outputPricePerToken: 0,
+      currency: 'USD'
+    },
+    capabilities: ['embeddings']
+  },
+  {
+    id: 'text-embedding-ada-002',
+    name: 'Text Embedding Ada 002',
+    contextWindow: 8191,
+    maxOutputTokens: 0,
+    pricing: {
+      inputPricePerToken: 0.0001 / 1000,
+      outputPricePerToken: 0,
+      currency: 'USD'
+    },
+    capabilities: ['embeddings']
+  }
+];
+
+/**
+ * Get model information by ID
+ */
+export function getModelInfo(modelId: string): ModelInfo | undefined {
+  return OPENAI_MODELS.find(model => model.id === modelId);
+}
+
+/**
+ * Get all chat models
+ */
+export function getChatModels(): ModelInfo[] {
+  return OPENAI_MODELS.filter(model =>
+    model.capabilities.includes('chat') || model.capabilities.includes('completion')
+  );
+}
+
+/**
+ * Get all embedding models
+ */
+export function getEmbeddingModels(): ModelInfo[] {
+  return OPENAI_MODELS.filter(model =>
+    model.capabilities.includes('embeddings')
+  );
+}
+
+/**
+ * Get all vision-capable models
+ */
+export function getVisionModels(): ModelInfo[] {
+  return OPENAI_MODELS.filter(model =>
+    model.capabilities.includes('vision')
+  );
+}
+
+/**
+ * Check if model supports function calling
+ */
+export function supportsFunctionCalling(modelId: string): boolean {
+  const model = getModelInfo(modelId);
+  return model?.capabilities.includes('function-calling') ?? false;
+}

package/src/types/openai-types.ts

@@ -0,0 +1,51 @@
+/*
+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 { AIProviderConfig } from '@bernierllc/ai-provider-core';
+
+/**
+ * OpenAI Provider Configuration
+ */
+export interface OpenAIProviderConfig extends AIProviderConfig {
+  providerName: 'openai';
+  organizationId?: string;
+  baseURL?: string;
+  timeout?: number;
+  maxRetries?: number;
+}
+
+/**
+ * OpenAI Function Definition (for function calling)
+ */
+export interface OpenAIFunction {
+  name: string;
+  description: string;
+  parameters: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+/**
+ * OpenAI Vision Request
+ */
+export interface OpenAIVisionRequest {
+  imageUrl: string;
+  prompt: string;
+  model?: string;
+  maxTokens?: number;
+}
+
+/**
+ * OpenAI Model Pricing Information
+ */
+export interface OpenAIModelPricing {
+  inputPrice: number; // USD per 1K tokens
+  outputPrice: number; // USD per 1K tokens
+}