@happyvertical/ai 0.79.0 → 0.80.1

package/dist/chunks/openai-CJEo69jb.js

@@ -1,882 +0,0 @@
-import OpenAI from "openai";
-import { b as normalizeBaseAIOptions, n as normalizeChatOptions, p as prepareRequestControls, A as AIError, a as normalizeImageGenerationOptions, C as ContentFilterError, c as ContextLengthError, M as ModelNotFoundError, R as RateLimitError, e as extractRetryAfterSeconds, d as AuthenticationError } from "./index-DCXO0nZA.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 = normalizeBaseAIOptions({
-      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();
-    let controls;
-    try {
-      const model = options.model || this.options.defaultModel || this.profile.defaultModel;
-      options = normalizeChatOptions(
-        this.options,
-        options,
-        this.profile.providerName,
-        model
-      );
-      controls = prepareRequestControls(this.options, options);
-      const request = {
-        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
-      };
-      if ((this.profile.providerName === "bifrost" || this.profile.providerName === "litellm") && (options.reasoning?.maxTokens || 0) > 0) {
-        request.reasoning = {
-          effort: options.reasoning?.effort,
-          max_tokens: options.reasoning?.maxTokens,
-          include_thoughts: options.reasoning?.includeThoughts
-        };
-      }
-      const response = await this.client.chat.completions.create(request, {
-        signal: controls.signal,
-        timeout: controls.timeout
-      });
-      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) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  /**
-   * 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,
-      signal: options.signal,
-      timeout: options.timeout,
-      reasoning: options.reasoning,
-      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,
-      signal: options.signal,
-      timeout: options.timeout,
-      reasoning: options.reasoning,
-      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, signal) {
-    if (Buffer.isBuffer(image)) {
-      return `data:image/png;base64,${image.toString("base64")}`;
-    }
-    if (image.startsWith("data:")) {
-      return image;
-    }
-    const response = await fetch(image, { signal });
-    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 = {}) {
-    let controls;
-    try {
-      const defaultPrompt = "Describe this image for a search index. Include objects, mood, lighting, and any visible text.";
-      controls = prepareRequestControls(this.options, options);
-      const imageUrl = await this.imageToBase64(image, controls.signal);
-      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,
-          signal: controls.signal,
-          timeout: controls.timeout,
-          reasoning: options.reasoning,
-          usageTags: options.usageTags
-        }
-      );
-      return response.content;
-    } catch (error) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  /**
-   * 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 = {}) {
-    let controls;
-    try {
-      const model = options.model || "dall-e-3";
-      options = normalizeImageGenerationOptions(
-        this.options,
-        options,
-        this.profile.providerName,
-        model
-      );
-      controls = prepareRequestControls(this.options, options);
-      const requestParams = {
-        model,
-        prompt,
-        n: model === "dall-e-3" ? 1 : options.n,
-        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, {
-        signal: controls.signal,
-        timeout: controls.timeout
-      });
-      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) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  /**
-   * 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();
-    let controls;
-    try {
-      const model = options.model || this.options.defaultModel || this.profile.defaultModel;
-      options = normalizeChatOptions(
-        this.options,
-        options,
-        this.profile.providerName,
-        model
-      );
-      controls = prepareRequestControls(this.options, options);
-      const request = {
-        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
-      };
-      if ((this.profile.providerName === "bifrost" || this.profile.providerName === "litellm") && (options.reasoning?.maxTokens || 0) > 0) {
-        request.reasoning = {
-          effort: options.reasoning?.effort,
-          max_tokens: options.reasoning?.maxTokens,
-          include_thoughts: options.reasoning?.includeThoughts
-        };
-      }
-      const stream = await this.client.chat.completions.create(request, {
-        signal: controls.signal,
-        timeout: controls.timeout
-      });
-      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) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          this.profile.providerName,
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  /**
-   * 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-CJEo69jb.js.map