@sparkleideas/providers 3.5.2-patch.1

package/src/openai-provider.ts

@@ -0,0 +1,490 @@
+/**
+ * V3 OpenAI Provider
+ *
+ * Supports GPT-4o, GPT-4, o1, and other OpenAI models.
+ *
+ * @module @sparkleideas/providers/openai-provider
+ */
+
+import { BaseProvider, BaseProviderOptions } from './base-provider.js';
+import {
+  LLMProvider,
+  LLMModel,
+  LLMRequest,
+  LLMResponse,
+  LLMStreamEvent,
+  ModelInfo,
+  ProviderCapabilities,
+  HealthCheckResult,
+  AuthenticationError,
+  RateLimitError,
+  ModelNotFoundError,
+  LLMProviderError,
+} from './types.js';
+
+interface OpenAIRequest {
+  model: string;
+  messages: Array<{
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+      id: string;
+      type: 'function';
+      function: { name: string; arguments: string };
+    }>;
+  }>;
+  temperature?: number;
+  max_tokens?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  stop?: string[];
+  stream?: boolean;
+  tools?: Array<{
+    type: 'function';
+    function: {
+      name: string;
+      description: string;
+      parameters: unknown;
+    };
+  }>;
+  tool_choice?: 'auto' | 'none' | 'required' | { type: 'function'; function: { name: string } };
+}
+
+interface OpenAIResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: string;
+      content: string | null;
+      tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: { name: string; arguments: string };
+      }>;
+    };
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export class OpenAIProvider extends BaseProvider {
+  readonly name: LLMProvider = 'openai';
+  readonly capabilities: ProviderCapabilities = {
+    supportedModels: [
+      'gpt-4o',
+      'gpt-4o-mini',
+      'gpt-4-turbo',
+      'gpt-4',
+      'gpt-3.5-turbo',
+      'o1-preview',
+      'o1-mini',
+      'o3-mini',
+    ],
+    maxContextLength: {
+      'gpt-4o': 128000,
+      'gpt-4o-mini': 128000,
+      'gpt-4-turbo': 128000,
+      'gpt-4': 8192,
+      'gpt-3.5-turbo': 16384,
+      'o1-preview': 128000,
+      'o1-mini': 128000,
+      'o3-mini': 200000,
+    },
+    maxOutputTokens: {
+      'gpt-4o': 16384,
+      'gpt-4o-mini': 16384,
+      'gpt-4-turbo': 4096,
+      'gpt-4': 8192,
+      'gpt-3.5-turbo': 4096,
+      'o1-preview': 32768,
+      'o1-mini': 65536,
+      'o3-mini': 100000,
+    },
+    supportsStreaming: true,
+    supportsToolCalling: true,
+    supportsSystemMessages: true,
+    supportsVision: true,
+    supportsAudio: true,
+    supportsFineTuning: true,
+    supportsEmbeddings: true,
+    supportsBatching: true,
+    rateLimit: {
+      requestsPerMinute: 10000,
+      tokensPerMinute: 2000000,
+      concurrentRequests: 500,
+    },
+    pricing: {
+      'gpt-4o': {
+        promptCostPer1k: 0.0025,
+        completionCostPer1k: 0.01,
+        currency: 'USD',
+      },
+      'gpt-4o-mini': {
+        promptCostPer1k: 0.00015,
+        completionCostPer1k: 0.0006,
+        currency: 'USD',
+      },
+      'gpt-4-turbo': {
+        promptCostPer1k: 0.01,
+        completionCostPer1k: 0.03,
+        currency: 'USD',
+      },
+      'gpt-4': {
+        promptCostPer1k: 0.03,
+        completionCostPer1k: 0.06,
+        currency: 'USD',
+      },
+      'gpt-3.5-turbo': {
+        promptCostPer1k: 0.0005,
+        completionCostPer1k: 0.0015,
+        currency: 'USD',
+      },
+      'o1-preview': {
+        promptCostPer1k: 0.015,
+        completionCostPer1k: 0.06,
+        currency: 'USD',
+      },
+      'o1-mini': {
+        promptCostPer1k: 0.003,
+        completionCostPer1k: 0.012,
+        currency: 'USD',
+      },
+      'o3-mini': {
+        promptCostPer1k: 0.0011,
+        completionCostPer1k: 0.0044,
+        currency: 'USD',
+      },
+    },
+  };
+
+  private baseUrl: string = 'https://api.openai.com/v1';
+  private headers: Record<string, string> = {};
+
+  constructor(options: BaseProviderOptions) {
+    super(options);
+  }
+
+  protected async doInitialize(): Promise<void> {
+    if (!this.config.apiKey) {
+      throw new AuthenticationError('OpenAI API key is required', 'openai');
+    }
+
+    this.baseUrl = this.config.apiUrl || 'https://api.openai.com/v1';
+    this.headers = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+
+    if (this.config.providerOptions?.organization) {
+      this.headers['OpenAI-Organization'] = this.config.providerOptions.organization as string;
+    }
+  }
+
+  protected async doComplete(request: LLMRequest): Promise<LLMResponse> {
+    const openAIRequest = this.buildRequest(request);
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.timeout || 60000);
+
+    try {
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: this.headers,
+        body: JSON.stringify(openAIRequest),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeout);
+
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+
+      const data = await response.json() as OpenAIResponse;
+      return this.transformResponse(data, request);
+    } catch (error) {
+      clearTimeout(timeout);
+      throw this.transformError(error);
+    }
+  }
+
+  protected async *doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {
+    const openAIRequest = this.buildRequest(request, true);
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), (this.config.timeout || 60000) * 2);
+
+    try {
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: this.headers,
+        body: JSON.stringify(openAIRequest),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+
+      const reader = response.body!.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            if (data === '[DONE]') {
+              // Estimate final usage
+              const promptTokens = this.estimateTokens(JSON.stringify(request.messages));
+              const model = request.model || this.config.model;
+              const baseModel = model.includes('/') ? model.split('/').pop()! : model;
+              const pricing = this.capabilities.pricing[model] || this.capabilities.pricing[baseModel];
+              const promptCostPer1k = pricing?.promptCostPer1k ?? 0;
+              const completionCostPer1k = pricing?.completionCostPer1k ?? 0;
+
+              yield {
+                type: 'done',
+                usage: {
+                  promptTokens,
+                  completionTokens: 100, // Estimate
+                  totalTokens: promptTokens + 100,
+                },
+                cost: {
+                  promptCost: (promptTokens / 1000) * promptCostPer1k,
+                  completionCost: (100 / 1000) * completionCostPer1k,
+                  totalCost:
+                    (promptTokens / 1000) * promptCostPer1k +
+                    (100 / 1000) * completionCostPer1k,
+                  currency: 'USD',
+                },
+              };
+              continue;
+            }
+
+            try {
+              const chunk = JSON.parse(data);
+              const delta = chunk.choices?.[0]?.delta;
+
+              if (delta?.content) {
+                yield {
+                  type: 'content',
+                  delta: { content: delta.content },
+                };
+              }
+
+              if (delta?.tool_calls) {
+                for (const toolCall of delta.tool_calls) {
+                  yield {
+                    type: 'tool_call',
+                    delta: {
+                      toolCall: {
+                        id: toolCall.id,
+                        type: 'function',
+                        function: toolCall.function,
+                      },
+                    },
+                  };
+                }
+              }
+            } catch {
+              // Ignore parse errors
+            }
+          }
+        }
+      }
+    } catch (error) {
+      clearTimeout(timeout);
+      throw this.transformError(error);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  async listModels(): Promise<LLMModel[]> {
+    return this.capabilities.supportedModels;
+  }
+
+  async getModelInfo(model: LLMModel): Promise<ModelInfo> {
+    const descriptions: Record<string, string> = {
+      'gpt-4o': 'Most capable GPT-4 model with vision and audio',
+      'gpt-4o-mini': 'Affordable and intelligent small model',
+      'gpt-4-turbo': 'GPT-4 Turbo with vision',
+      'gpt-4': 'High capability model',
+      'gpt-3.5-turbo': 'Fast and efficient model',
+      'o1-preview': 'Reasoning model for complex tasks',
+      'o1-mini': 'Fast reasoning model',
+      'o3-mini': 'Latest reasoning model',
+    };
+
+    return {
+      model,
+      name: model,
+      description: descriptions[model] || 'OpenAI language model',
+      contextLength: this.capabilities.maxContextLength[model] || 8192,
+      maxOutputTokens: this.capabilities.maxOutputTokens[model] || 4096,
+      supportedFeatures: [
+        'chat',
+        'completion',
+        'tool_calling',
+        ...(model.includes('gpt-4') ? ['vision'] : []),
+      ],
+      pricing: this.capabilities.pricing[model],
+    };
+  }
+
+  protected async doHealthCheck(): Promise<HealthCheckResult> {
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: this.headers,
+      });
+
+      return {
+        healthy: response.ok,
+        timestamp: new Date(),
+        ...(response.ok ? {} : { error: `HTTP ${response.status}` }),
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  private buildRequest(request: LLMRequest, stream = false): OpenAIRequest {
+    const openAIRequest: OpenAIRequest = {
+      model: request.model || this.config.model,
+      messages: request.messages.map((msg) => ({
+        role: msg.role,
+        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        ...(msg.name && { name: msg.name }),
+        ...(msg.toolCallId && { tool_call_id: msg.toolCallId }),
+        ...(msg.toolCalls && { tool_calls: msg.toolCalls }),
+      })),
+      stream,
+    };
+
+    if (request.temperature !== undefined || this.config.temperature !== undefined) {
+      openAIRequest.temperature = request.temperature ?? this.config.temperature;
+    }
+
+    if (request.maxTokens || this.config.maxTokens) {
+      openAIRequest.max_tokens = request.maxTokens || this.config.maxTokens;
+    }
+
+    if (request.topP !== undefined || this.config.topP !== undefined) {
+      openAIRequest.top_p = request.topP ?? this.config.topP;
+    }
+
+    if (request.frequencyPenalty !== undefined || this.config.frequencyPenalty !== undefined) {
+      openAIRequest.frequency_penalty = request.frequencyPenalty ?? this.config.frequencyPenalty;
+    }
+
+    if (request.presencePenalty !== undefined || this.config.presencePenalty !== undefined) {
+      openAIRequest.presence_penalty = request.presencePenalty ?? this.config.presencePenalty;
+    }
+
+    if (request.stopSequences || this.config.stopSequences) {
+      openAIRequest.stop = request.stopSequences || this.config.stopSequences;
+    }
+
+    if (request.tools) {
+      openAIRequest.tools = request.tools;
+      openAIRequest.tool_choice = request.toolChoice;
+    }
+
+    return openAIRequest;
+  }
+
+  private transformResponse(data: OpenAIResponse, request: LLMRequest): LLMResponse {
+    const choice = data.choices[0];
+    const model = request.model || this.config.model;
+    // Handle OpenRouter and other compatible APIs with different model naming
+    const baseModel = model.includes('/') ? model.split('/').pop()! : model;
+    const pricing = this.capabilities.pricing[model] || this.capabilities.pricing[baseModel];
+
+    // Default pricing if model not found
+    const promptCostPer1k = pricing?.promptCostPer1k ?? 0;
+    const completionCostPer1k = pricing?.completionCostPer1k ?? 0;
+
+    const promptCost = (data.usage.prompt_tokens / 1000) * promptCostPer1k;
+    const completionCost = (data.usage.completion_tokens / 1000) * completionCostPer1k;
+
+    return {
+      id: data.id,
+      model: model as LLMModel,
+      provider: 'openai',
+      content: choice.message.content || '',
+      toolCalls: choice.message.tool_calls,
+      usage: {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens,
+      },
+      cost: {
+        promptCost,
+        completionCost,
+        totalCost: promptCost + completionCost,
+        currency: 'USD',
+      },
+      finishReason: choice.finish_reason,
+    };
+  }
+
+  private async handleErrorResponse(response: Response): Promise<never> {
+    const errorText = await response.text();
+    let errorData: { error?: { message?: string } };
+
+    try {
+      errorData = JSON.parse(errorText);
+    } catch {
+      errorData = { error: { message: errorText } };
+    }
+
+    const message = errorData.error?.message || 'Unknown error';
+
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message, 'openai', errorData);
+      case 429:
+        const retryAfter = response.headers.get('retry-after');
+        throw new RateLimitError(
+          message,
+          'openai',
+          retryAfter ? parseInt(retryAfter) : undefined,
+          errorData
+        );
+      case 404:
+        throw new ModelNotFoundError(this.config.model, 'openai', errorData);
+      default:
+        throw new LLMProviderError(
+          message,
+          `OPENAI_${response.status}`,
+          'openai',
+          response.status,
+          response.status >= 500,
+          errorData
+        );
+    }
+  }
+}