@happyvertical/ai 0.74.8

package/dist/chunks/openai-5snI2diE.js

@@ -0,0 +1,749 @@
+import OpenAI from "openai";
+import { A as AIError, C as ContentFilterError, a as ContextLengthError, M as ModelNotFoundError, R as RateLimitError, e as extractRetryAfterSeconds, b as AuthenticationError } from "./index-BT4thAvS.js";
+import { e as emitUsage } from "./usage-DMWiJ2oB.js";
+const OPENAI_PROFILE = {
+  providerLabel: "OpenAI",
+  providerName: "openai",
+  defaultModel: "gpt-4o",
+  capabilities: {
+    chat: true,
+    completion: true,
+    embeddings: true,
+    streaming: true,
+    functions: true,
+    vision: true,
+    fineTuning: true,
+    imageEmbeddings: true,
+    imageGeneration: true,
+    tts: false,
+    voiceCloning: false,
+    voiceDesign: false,
+    maxContextLength: 128e3,
+    supportedOperations: [
+      "chat",
+      "completion",
+      "embedding",
+      "streaming",
+      "functions",
+      "vision",
+      "image_embedding",
+      "image_generation"
+    ]
+  },
+  describeModel: (modelId) => `OpenAI model: ${modelId}`,
+  getContextLength(modelId) {
+    if (modelId.includes("gpt-4o")) return 128e3;
+    if (modelId.includes("gpt-4.1")) return 128e3;
+    if (modelId.includes("gpt-4-turbo")) return 128e3;
+    if (modelId.includes("gpt-4")) return 8192;
+    if (modelId.includes("gpt-3.5-turbo")) return 16385;
+    if (modelId.includes("text-embedding")) return 8192;
+    return 4096;
+  },
+  getModelCapabilities(modelId) {
+    const capabilities = ["text"];
+    if (modelId.includes("gpt")) {
+      capabilities.push("chat", "functions");
+    }
+    if (modelId.includes("vision") || modelId === "gpt-4o" || modelId.includes("gpt-4.1")) {
+      capabilities.push("vision");
+    }
+    if (modelId.includes("embedding")) {
+      capabilities.push("embeddings");
+    }
+    return capabilities;
+  },
+  shouldIncludeModel(modelId) {
+    return modelId.includes("gpt") || modelId.includes("text-embedding");
+  },
+  supportsFunctions(modelId) {
+    return modelId.includes("gpt-4") || modelId.includes("gpt-3.5");
+  },
+  supportsVision(modelId) {
+    return modelId.includes("vision") || modelId === "gpt-4o" || modelId.includes("gpt-4.1");
+  }
+};
+class OpenAIProvider {
+  client;
+  options;
+  profile;
+  /**
+   * Creates a new OpenAI provider instance
+   * @param options - Configuration options for the OpenAI provider
+   */
+  constructor(options, profile = OPENAI_PROFILE) {
+    this.profile = profile;
+    this.options = {
+      defaultModel: this.profile.defaultModel,
+      ...options
+    };
+    this.client = new OpenAI({
+      apiKey: this.options.apiKey,
+      baseURL: this.options.baseUrl,
+      organization: this.options.organization,
+      timeout: this.options.timeout,
+      maxRetries: this.options.maxRetries,
+      defaultHeaders: this.options.headers
+    });
+  }
+  /**
+   * Generate a chat completion using OpenAI's chat models
+   * @param messages - Array of conversation messages
+   * @param options - Optional configuration for the chat completion
+   * @returns Promise resolving to the AI response with content and metadata
+   * @throws {AIError} When the API request fails or returns invalid data
+   *
+   * @example
+   * ```typescript
+   * const response = await provider.chat([
+   *   { role: 'system', content: 'You are a helpful assistant.' },
+   *   { role: 'user', content: 'What is the capital of France?' }
+   * ], {
+   *   model: 'gpt-4o',
+   *   temperature: 0.7,
+   *   maxTokens: 150
+   * });
+   * console.log(response.content); // "Paris is the capital of France."
+   * ```
+   */
+  async chat(messages, options = {}) {
+    const startTime = Date.now();
+    try {
+      const model = options.model || this.options.defaultModel || this.profile.defaultModel;
+      const response = await this.client.chat.completions.create({
+        model,
+        messages: this.mapMessagesToOpenAI(messages),
+        max_tokens: options.maxTokens,
+        temperature: options.temperature,
+        top_p: options.topP,
+        n: options.n,
+        stop: options.stop,
+        frequency_penalty: options.frequencyPenalty,
+        presence_penalty: options.presencePenalty,
+        user: options.user,
+        tools: options.tools?.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters
+          }
+        })),
+        tool_choice: this.mapToolChoice(options.toolChoice),
+        response_format: options.responseFormat,
+        seed: options.seed,
+        stream: false
+      });
+      const choice = response.choices[0];
+      if (!choice) {
+        throw new AIError(
+          `No choices returned from ${this.profile.providerLabel}`,
+          "NO_CHOICES",
+          this.profile.providerName
+        );
+      }
+      const usage = this.mapUsage(response.usage);
+      emitUsage(
+        this.options,
+        this.profile.providerName,
+        "chat",
+        response.model || model,
+        usage,
+        startTime,
+        options.usageTags
+      );
+      return {
+        content: choice.message.content || "",
+        usage,
+        model: response.model,
+        finishReason: this.mapFinishReason(choice.finish_reason),
+        toolCalls: choice.message.tool_calls?.filter((call) => call.type === "function").map((call) => ({
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.function.name,
+            arguments: call.function.arguments
+          }
+        }))
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Generate a text completion for a given prompt
+   * @param prompt - The text prompt to complete
+   * @param options - Optional configuration for the completion
+   * @returns Promise resolving to the AI response
+   * @throws {AIError} When the API request fails
+   *
+   * @example
+   * ```typescript
+   * const response = await provider.complete('The weather today is', {
+   *   model: 'gpt-4o',
+   *   maxTokens: 50,
+   *   temperature: 0.5
+   * });
+   * ```
+   */
+  async complete(prompt, options = {}) {
+    return this.chat([{ role: "user", content: prompt }], {
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP,
+      n: options.n,
+      stop: options.stop,
+      stream: options.stream,
+      onProgress: options.onProgress,
+      usageTags: options.usageTags
+    });
+  }
+  /**
+   * Simple message interface for single-turn interactions with optional history
+   *
+   * @param text - The message text to send
+   * @param options - Configuration options including history, model, etc.
+   * @returns Promise resolving to the response content string
+   *
+   * @example
+   * ```typescript
+   * // Simple usage
+   * const response = await provider.message('Hello!');
+   *
+   * // With options
+   * const response = await provider.message('Analyze this', {
+   *   model: 'gpt-4o',
+   *   responseFormat: { type: 'json_object' }
+   * });
+   *
+   * // With history
+   * const response = await provider.message('What was my question?', {
+   *   history: [
+   *     { role: 'user', content: 'What is 2+2?' },
+   *     { role: 'assistant', content: '4' }
+   *   ]
+   * });
+   * ```
+   */
+  async message(text, options = {}) {
+    const messages = [
+      ...options.history || [],
+      { role: options.role || "user", content: text }
+    ];
+    const response = await this.chat(messages, {
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP,
+      stop: options.stop,
+      stream: options.stream,
+      frequencyPenalty: options.frequencyPenalty,
+      presencePenalty: options.presencePenalty,
+      responseFormat: options.responseFormat,
+      seed: options.seed,
+      tools: options.tools,
+      toolChoice: options.toolChoice,
+      onProgress: options.onProgress,
+      usageTags: options.usageTags
+    });
+    return response.content;
+  }
+  /**
+   * Generate embeddings for the given text(s)
+   * @param text - Single text string or array of texts to embed
+   * @param options - Optional configuration for embeddings
+   * @returns Promise resolving to embeddings response with vector arrays
+   * @throws {AIError} When the API request fails
+   *
+   * @example
+   * ```typescript
+   * // Single text embedding
+   * const response1 = await provider.embed('Hello world');
+   * console.log(response1.embeddings[0]); // Array of numbers
+   *
+   * // Multiple text embeddings
+   * const response2 = await provider.embed(['Text 1', 'Text 2']);
+   * console.log(response2.embeddings.length); // 2
+   * ```
+   */
+  async embed(text, options = {}) {
+    const startTime = Date.now();
+    try {
+      const model = options.model || "text-embedding-3-small";
+      const input = Array.isArray(text) ? text : [text];
+      const response = await this.client.embeddings.create({
+        model,
+        input,
+        encoding_format: options.encodingFormat,
+        dimensions: options.dimensions,
+        user: options.user
+      });
+      const usage = this.mapUsage(response.usage);
+      emitUsage(
+        this.options,
+        this.profile.providerName,
+        "embed",
+        response.model || model,
+        usage,
+        startTime,
+        options.usageTags
+      );
+      return {
+        embeddings: response.data.map((item) => item.embedding),
+        usage,
+        model: response.model
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Convert an image to a base64 data URL
+   * @param image - Image as URL, base64 data URL, or Buffer
+   * @returns base64 data URL string
+   * @private
+   */
+  async imageToBase64(image) {
+    if (Buffer.isBuffer(image)) {
+      return `data:image/png;base64,${image.toString("base64")}`;
+    }
+    if (image.startsWith("data:")) {
+      return image;
+    }
+    const response = await fetch(image);
+    if (!response.ok) {
+      throw new AIError(
+        `Failed to fetch image: ${response.status} ${response.statusText}`,
+        "IMAGE_FETCH_ERROR",
+        this.profile.providerName
+      );
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const contentType = response.headers.get("content-type") || "image/png";
+    return `data:${contentType};base64,${buffer.toString("base64")}`;
+  }
+  /**
+   * Generate a text description of an image
+   * @param image - Image as URL, base64 data URL, or Buffer
+   * @param prompt - Custom prompt for description (optional)
+   * @param options - Optional configuration
+   * @returns Promise resolving to the description string
+   *
+   * @example
+   * ```typescript
+   * const description = await provider.describeImage('https://example.com/image.jpg');
+   * ```
+   */
+  async describeImage(image, prompt, options = {}) {
+    try {
+      const defaultPrompt = "Describe this image for a search index. Include objects, mood, lighting, and any visible text.";
+      const imageUrl = await this.imageToBase64(image);
+      const response = await this.chat(
+        [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: prompt || defaultPrompt },
+              {
+                type: "image_url",
+                image_url: {
+                  url: imageUrl,
+                  detail: options.detail || "auto"
+                }
+              }
+            ]
+          }
+        ],
+        {
+          model: options.model || this.options.defaultModel || this.profile.defaultModel,
+          maxTokens: options.maxTokens || 500
+        }
+      );
+      return response.content;
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Generate embeddings for an image using describe-then-embed pattern
+   * @param image - Image as URL, base64 data URL, or Buffer
+   * @param options - Optional configuration for image embeddings
+   * @returns Promise resolving to embeddings response
+   *
+   * @example
+   * ```typescript
+   * const embedding = await provider.embedImage('https://example.com/image.jpg');
+   * ```
+   */
+  async embedImage(image, options = {}) {
+    try {
+      const description = await this.describeImage(
+        image,
+        "Describe this image in detail for semantic embedding. Include all visible objects, colors, textures, composition, text, people, actions, and overall scene context."
+      );
+      return this.embed(description, {
+        model: options.model || "text-embedding-3-small",
+        dimensions: options.dimensions,
+        user: options.user
+      });
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Generate an image from a text prompt using DALL-E
+   * @param prompt - Text description of the image to generate
+   * @param options - Optional configuration for image generation
+   * @returns Promise resolving to generated image(s)
+   *
+   * @example
+   * ```typescript
+   * const result = await provider.generateImage('A sunset over mountains');
+   * fs.writeFileSync('image.png', result.images[0].data);
+   * ```
+   */
+  async generateImage(prompt, options = {}) {
+    try {
+      const model = options.model || "dall-e-3";
+      const requestParams = {
+        model,
+        prompt,
+        n: model === "dall-e-3" ? 1 : options.n || 1,
+        size: options.size || "1024x1024",
+        response_format: options.outputFormat === "url" ? "url" : "b64_json"
+      };
+      if (model === "dall-e-3") {
+        if (options.style) {
+          requestParams.style = options.style;
+        }
+        if (options.quality) {
+          requestParams.quality = options.quality;
+        }
+      }
+      const response = await this.client.images.generate(requestParams);
+      const images = (response.data || []).map((item) => {
+        let data;
+        const mimeType = "image/png";
+        if (options.outputFormat === "url") {
+          data = item.url || "";
+        } else if (options.outputFormat === "base64") {
+          data = item.b64_json || "";
+        } else {
+          data = Buffer.from(item.b64_json || "", "base64");
+        }
+        return {
+          data,
+          mimeType,
+          revisedPrompt: item.revised_prompt
+        };
+      });
+      return {
+        images,
+        model
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Stream a chat completion response in real-time
+   * @param messages - Array of conversation messages
+   * @param options - Optional configuration for the chat completion
+   * @yields Individual content chunks as they arrive
+   * @throws {AIError} When the streaming request fails
+   *
+   * @example
+   * ```typescript
+   * for await (const chunk of provider.stream([
+   *   { role: 'user', content: 'Write a story about AI' }
+   * ])) {
+   *   process.stdout.write(chunk);
+   * }
+   * ```
+   */
+  async *stream(messages, options = {}) {
+    const startTime = Date.now();
+    try {
+      const model = options.model || this.options.defaultModel || this.profile.defaultModel;
+      const stream = await this.client.chat.completions.create({
+        model,
+        messages: this.mapMessagesToOpenAI(messages),
+        max_tokens: options.maxTokens,
+        temperature: options.temperature,
+        top_p: options.topP,
+        stop: options.stop,
+        frequency_penalty: options.frequencyPenalty,
+        presence_penalty: options.presencePenalty,
+        user: options.user,
+        stream: true
+      });
+      for await (const chunk of stream) {
+        const content = chunk.choices[0]?.delta?.content;
+        if (content) {
+          if (options.onProgress) {
+            options.onProgress(content);
+          }
+          yield content;
+        }
+      }
+      emitUsage(
+        this.options,
+        this.profile.providerName,
+        "stream",
+        model,
+        void 0,
+        startTime,
+        options.usageTags
+      );
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Count the number of tokens in the given text
+   * @param text - The text to count tokens for
+   * @returns Promise resolving to the estimated token count
+   *
+   * @remarks
+   * OpenAI doesn't provide a direct token counting API, so this is an approximation
+   * based on the general rule of ~4 characters per token. For precise counting,
+   * consider using a dedicated tokenizer library.
+   *
+   * @example
+   * ```typescript
+   * const count = await provider.countTokens('Hello, world!');
+   * console.log(count); // Approximately 4 tokens
+   * ```
+   */
+  async countTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Get a list of available OpenAI models
+   * @returns Promise resolving to an array of model information
+   * @throws {AIError} When the API request fails
+   *
+   * @example
+   * ```typescript
+   * const models = await provider.getModels();
+   * const gptModels = models.filter(m => m.id.includes('gpt'));
+   * ```
+   */
+  async getModels() {
+    try {
+      const response = await this.client.models.list();
+      return response.data.filter((model) => this.profile.shouldIncludeModel(model.id)).map((model) => ({
+        id: model.id,
+        name: model.id,
+        description: this.profile.describeModel(model.id),
+        contextLength: this.profile.getContextLength(model.id),
+        capabilities: this.profile.getModelCapabilities(model.id),
+        supportsFunctions: this.profile.supportsFunctions(model.id),
+        supportsVision: this.profile.supportsVision(model.id)
+      }));
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Get the capabilities supported by this OpenAI provider
+   * @returns Promise resolving to provider capabilities
+   *
+   * @example
+   * ```typescript
+   * const caps = await provider.getCapabilities();
+   * if (caps.functions) {
+   *   // Provider supports function calling
+   * }
+   * ```
+   */
+  async getCapabilities() {
+    return { ...this.profile.capabilities };
+  }
+  // ============================================================================
+  // TTS Methods (Not supported - use Qwen3-TTS provider)
+  // ============================================================================
+  async synthesizeSpeech(_text, _options) {
+    throw new AIError(
+      `TTS is not supported by ${this.profile.providerLabel} provider. Use Qwen3-TTS provider.`,
+      "NOT_IMPLEMENTED",
+      this.profile.providerName
+    );
+  }
+  streamSpeech(_text, _options) {
+    const error = new AIError(
+      `TTS streaming is not supported by ${this.profile.providerLabel} provider. Use Qwen3-TTS provider.`,
+      "NOT_IMPLEMENTED",
+      this.profile.providerName
+    );
+    return {
+      [Symbol.asyncIterator]: () => ({
+        next: () => Promise.reject(error)
+      })
+    };
+  }
+  async cloneVoice(_options) {
+    throw new AIError(
+      `Voice cloning is not supported by ${this.profile.providerLabel} provider. Use Qwen3-TTS provider.`,
+      "NOT_IMPLEMENTED",
+      this.profile.providerName
+    );
+  }
+  async designVoice(_options) {
+    throw new AIError(
+      `Voice design is not supported by ${this.profile.providerLabel} provider. Use Qwen3-TTS provider.`,
+      "NOT_IMPLEMENTED",
+      this.profile.providerName
+    );
+  }
+  async getVoices(_options) {
+    throw new AIError(
+      `Voice listing is not supported by ${this.profile.providerLabel} provider. Use Qwen3-TTS provider.`,
+      "NOT_IMPLEMENTED",
+      this.profile.providerName
+    );
+  }
+  /**
+   * Maps internal AI messages to OpenAI's message format
+   * @param messages - Array of internal AI messages
+   * @returns Array of OpenAI-compatible message parameters
+   * @private
+   */
+  mapMessagesToOpenAI(messages) {
+    return messages.map((message) => {
+      let content;
+      if (typeof message.content === "string") {
+        content = message.content;
+      } else {
+        content = message.content.map((part) => {
+          if (part.type === "text") {
+            return { type: "text", text: part.text };
+          }
+          return {
+            type: "image_url",
+            image_url: {
+              url: part.image_url.url,
+              detail: part.image_url.detail
+            }
+          };
+        });
+      }
+      const baseMessage = {
+        role: message.role,
+        content
+      };
+      if (message.name && (message.role === "system" || message.role === "user" || message.role === "function")) {
+        baseMessage.name = message.name;
+      }
+      if (message.tool_calls && message.role === "assistant") {
+        baseMessage.tool_calls = message.tool_calls;
+      }
+      return baseMessage;
+    });
+  }
+  /**
+   * Maps internal tool choice format to OpenAI's tool choice format
+   * @param toolChoice - Internal tool choice specification
+   * @returns OpenAI-compatible tool choice option or undefined
+   * @private
+   */
+  mapToolChoice(toolChoice) {
+    if (!toolChoice) return void 0;
+    if (typeof toolChoice === "string") return toolChoice;
+    return {
+      type: "function",
+      function: { name: toolChoice.function.name }
+    };
+  }
+  /**
+   * Maps OpenAI usage information to internal token usage format
+   * @param usage - OpenAI usage object from API response
+   * @returns Internal token usage object or undefined
+   * @private
+   */
+  mapUsage(usage) {
+    if (!usage) return void 0;
+    return {
+      promptTokens: usage.prompt_tokens || 0,
+      completionTokens: usage.completion_tokens || 0,
+      totalTokens: usage.total_tokens || 0
+    };
+  }
+  /**
+   * Maps OpenAI finish reason to internal finish reason format
+   * @param reason - OpenAI finish reason from API response
+   * @returns Internal finish reason
+   * @private
+   */
+  mapFinishReason(reason) {
+    switch (reason) {
+      case "stop":
+        return "stop";
+      case "length":
+        return "length";
+      case "tool_calls":
+        return "tool_calls";
+      case "content_filter":
+        return "content_filter";
+      default:
+        return "stop";
+    }
+  }
+  /**
+   * Gets the context length for a given OpenAI model
+   * @param modelId - The OpenAI model identifier
+   * @returns Maximum context length in tokens
+   * @private
+   */
+  /**
+   * Maps OpenAI API errors to internal AI error types
+   * @param error - The error object from OpenAI API
+   * @returns Appropriate internal AI error instance
+   * @private
+   */
+  mapError(error) {
+    if (error instanceof OpenAI.APIError) {
+      switch (error.status) {
+        case 401:
+          return new AuthenticationError(this.profile.providerName);
+        case 429: {
+          return new RateLimitError(
+            this.profile.providerName,
+            extractRetryAfterSeconds(error)
+          );
+        }
+        case 404:
+          return new ModelNotFoundError(
+            error.message,
+            this.profile.providerName
+          );
+        case 413:
+          return new ContextLengthError(this.profile.providerName);
+        default:
+          if (error.message.includes("content_filter")) {
+            return new ContentFilterError(this.profile.providerName);
+          }
+          return new AIError(
+            error.message,
+            "API_ERROR",
+            this.profile.providerName
+          );
+      }
+    }
+    if (error instanceof AIError) {
+      return error;
+    }
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    return new AIError(
+      errorMessage,
+      "UNKNOWN_ERROR",
+      this.profile.providerName
+    );
+  }
+}
+export {
+  OpenAIProvider
+};
+//# sourceMappingURL=openai-5snI2diE.js.map