@happyvertical/ai 0.79.0 → 0.80.1

package/dist/chunks/index-DCXO0nZA.js

@@ -1,1293 +0,0 @@
-import { ValidationError, ApiError, loadEnvConfig } from "@happyvertical/utils";
-import OpenAI from "openai";
-const AI_PROVIDER_TYPES = [
-  "openai",
-  "litellm",
-  "bifrost",
-  "ollama",
-  "gemini",
-  "anthropic",
-  "huggingface",
-  "bedrock",
-  "claude-cli",
-  "qwen3-tts"
-];
-function extractTextContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-}
-class AIError extends Error {
-  constructor(message, code, provider, model, retryable = false) {
-    super(message);
-    this.code = code;
-    this.provider = provider;
-    this.model = model;
-    this.retryable = retryable;
-    this.name = "AIError";
-  }
-}
-class AuthenticationError extends AIError {
-  constructor(provider) {
-    super("Authentication failed", "AUTH_ERROR", provider, void 0, false);
-    this.name = "AuthenticationError";
-  }
-}
-class RateLimitError extends AIError {
-  retryAfter;
-  constructor(provider, retryAfter) {
-    super(
-      `Rate limit exceeded${retryAfter ? `, retry after ${retryAfter}s` : ""}`,
-      "RATE_LIMIT",
-      provider,
-      void 0,
-      true
-    );
-    this.name = "RateLimitError";
-    this.retryAfter = retryAfter;
-  }
-}
-class ModelNotFoundError extends AIError {
-  constructor(model, provider) {
-    super(
-      `Model not found: ${model}`,
-      "MODEL_NOT_FOUND",
-      provider,
-      model,
-      false
-    );
-    this.name = "ModelNotFoundError";
-  }
-}
-class ContextLengthError extends AIError {
-  constructor(provider, model) {
-    super(
-      "Input exceeds maximum context length",
-      "CONTEXT_LENGTH_EXCEEDED",
-      provider,
-      model,
-      false
-    );
-    this.name = "ContextLengthError";
-  }
-}
-class ContentFilterError extends AIError {
-  constructor(provider, model) {
-    super(
-      "Content filtered by safety systems",
-      "CONTENT_FILTERED",
-      provider,
-      model,
-      false
-    );
-    this.name = "ContentFilterError";
-  }
-}
-function isOpenAIClientOptions(options) {
-  return options.type === "openai" && "apiKey" in options && !!options.apiKey;
-}
-function isAIClientInstance(value) {
-  return value instanceof AIClient;
-}
-class AIClient {
-  /**
-   * Configuration options for this client
-   */
-  options;
-  /**
-   * Creates a new AIClient
-   *
-   * @param options - Client configuration options
-   */
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Sends a message to the AI
-   * Base implementation returns a placeholder response
-   *
-   * @param text - Message text
-   * @param options - Message options
-   * @returns Promise resolving to a placeholder response
-   */
-  async message(_text, _options = { role: "user" }) {
-    return "not a real ai message, this is the base class!";
-  }
-  /**
-   * Factory method to create appropriate AI client based on options
-   *
-   * @param options - Client configuration options
-   * @returns Promise resolving to an initialized AI client
-   * @throws Error if client type is invalid
-   */
-  static async create(options) {
-    if (isAIClientInstance(options)) {
-      return options;
-    }
-    const clientOptions = options;
-    if (isOpenAIClientOptions(clientOptions)) {
-      return OpenAIClient.create(clientOptions);
-    }
-    const providedType = clientOptions.type;
-    if (providedType && providedType !== "openai") {
-      const { getAI: getAI2 } = await Promise.resolve().then(() => factory);
-      return await getAI2(clientOptions);
-    }
-    if (providedType === "openai") {
-      throw new ValidationError(
-        "OpenAI API key is required but missing or empty",
-        {
-          supportedTypes: [...AI_PROVIDER_TYPES],
-          providedType,
-          hint: "Set OPENAI_API_KEY environment variable or pass apiKey in options"
-        }
-      );
-    }
-    throw new ValidationError("Invalid client type specified", {
-      supportedTypes: [...AI_PROVIDER_TYPES],
-      providedType
-    });
-  }
-  /**
-   * Gets a text completion from the AI
-   * In base class, delegates to message method
-   *
-   * @param text - Input text for completion
-   * @param options - Completion options
-   * @returns Promise resolving to the completion result
-   */
-  textCompletion(text, options = {
-    role: "user"
-  }) {
-    return this.message(text, options);
-  }
-}
-async function getOpenAI(options) {
-  return new OpenAI({
-    apiKey: options.apiKey,
-    baseURL: options.baseUrl
-  });
-}
-class OpenAIClient extends AIClient {
-  /**
-   * OpenAI client instance
-   */
-  openai;
-  /**
-   * Configuration options for this client
-   */
-  options;
-  /**
-   * Creates a new OpenAIClient
-   *
-   * @param options - OpenAI client configuration options
-   */
-  constructor(options) {
-    super(options);
-    this.options = options;
-  }
-  /**
-   * Sends a message to OpenAI
-   *
-   * @param text - Message text
-   * @param options - Message options
-   * @returns Promise resolving to the OpenAI response
-   */
-  async message(text, options = { role: "user" }) {
-    const response = await this.textCompletion(text, options);
-    return response;
-  }
-  /**
-   * Factory method to create and initialize an OpenAIClient
-   *
-   * @param options - OpenAI client configuration options
-   * @returns Promise resolving to an initialized OpenAIClient
-   */
-  static async create(options) {
-    const client = new OpenAIClient(options);
-    await client.initialize();
-    return client;
-  }
-  /**
-   * Initializes the OpenAI client
-   */
-  async initialize() {
-    this.openai = new OpenAI({
-      apiKey: this.options.apiKey,
-      baseURL: this.options.baseUrl
-    });
-  }
-  /**
-   * Sends a text completion request to the OpenAI API
-   *
-   * @param message - The message to send
-   * @param options - Configuration options for the completion request
-   * @returns Promise resolving to the completion text
-   * @throws Error if the OpenAI API response is invalid
-   */
-  async textCompletion(message, options = {}) {
-    const {
-      model = "gpt-4o",
-      role = "user",
-      history = [],
-      name: _name,
-      frequencyPenalty = 0,
-      logitBias,
-      logprobs = false,
-      topLogprobs,
-      maxTokens,
-      n = 1,
-      presencePenalty = 0,
-      responseFormat,
-      seed,
-      stop,
-      stream: _stream = false,
-      temperature = 1,
-      topProbability: topP = 1,
-      tools,
-      toolChoice,
-      user,
-      onProgress
-    } = options;
-    const messages = [
-      ...history,
-      {
-        role,
-        content: message
-      }
-    ];
-    if (onProgress) {
-      const stream = await this.openai.chat.completions.create({
-        model,
-        messages,
-        stream: true,
-        frequency_penalty: frequencyPenalty,
-        logit_bias: logitBias,
-        logprobs,
-        top_logprobs: topLogprobs,
-        max_tokens: maxTokens,
-        n,
-        presence_penalty: presencePenalty,
-        response_format: responseFormat,
-        seed,
-        stop,
-        temperature,
-        top_p: topP,
-        tools,
-        tool_choice: toolChoice,
-        user
-      });
-      let fullContent = "";
-      for await (const chunk of stream) {
-        const content = chunk.choices[0]?.delta?.content || "";
-        fullContent += content;
-        onProgress(content);
-      }
-      return fullContent;
-    }
-    const response = await this.openai.chat.completions.create({
-      model,
-      messages,
-      frequency_penalty: frequencyPenalty,
-      logit_bias: logitBias,
-      logprobs,
-      top_logprobs: topLogprobs,
-      max_tokens: maxTokens,
-      n,
-      presence_penalty: presencePenalty,
-      response_format: responseFormat,
-      seed,
-      stop,
-      stream: false,
-      temperature,
-      top_p: topP,
-      tools,
-      tool_choice: toolChoice,
-      user
-    });
-    const choice = response.choices[0];
-    if (!choice || !choice.message || !choice.message.content) {
-      throw new ApiError("Invalid response from OpenAI API: Missing content", {
-        model,
-        responseId: response.id,
-        choices: response.choices?.length || 0,
-        hasChoice: !!choice,
-        hasMessage: !!choice?.message,
-        hasContent: !!choice?.message?.content
-      });
-    }
-    return choice.message.content;
-  }
-}
-async function getAIClient(options) {
-  const { getAI: getAI2 } = await Promise.resolve().then(() => factory);
-  return await getAI2(options);
-}
-const RATE_LIMITED_METHODS = /* @__PURE__ */ new Set([
-  "chat",
-  "complete",
-  "message",
-  "embed",
-  "embedImage",
-  "describeImage",
-  "generateImage",
-  "getModels",
-  "synthesizeSpeech",
-  "cloneVoice",
-  "designVoice",
-  "getVoices"
-]);
-const MAX_BUDGET_COORDINATORS = 128;
-const BUDGET_COORDINATOR_TTL_MS = 15 * 60 * 1e3;
-class BudgetCoordinator {
-  nextAvailableAt = 0;
-  pendingSchedules = 0;
-  tail = Promise.resolve();
-  lastUsedAt = Date.now();
-  touch() {
-    this.lastUsedAt = Date.now();
-  }
-  schedule(work) {
-    this.pendingSchedules += 1;
-    this.touch();
-    const run = this.tail.then(work, work);
-    this.tail = run.then(
-      () => void 0,
-      () => void 0
-    );
-    return run.finally(() => {
-      this.pendingSchedules = Math.max(0, this.pendingSchedules - 1);
-      this.touch();
-    });
-  }
-  async waitUntilReady() {
-    this.touch();
-    const delayMs = this.nextAvailableAt - Date.now();
-    if (delayMs > 0) {
-      await sleep(delayMs);
-    }
-  }
-  delayFor(delayMs) {
-    this.touch();
-    if (delayMs <= 0) {
-      return;
-    }
-    this.nextAvailableAt = Math.max(this.nextAvailableAt, Date.now() + delayMs);
-  }
-  isEvictable(now) {
-    return this.pendingSchedules === 0 && now >= this.nextAvailableAt;
-  }
-  isExpired(now) {
-    return this.isEvictable(now) && now - this.lastUsedAt >= BUDGET_COORDINATOR_TTL_MS;
-  }
-  getLastUsedAt() {
-    return this.lastUsedAt;
-  }
-}
-const budgetCoordinators = /* @__PURE__ */ new Map();
-function sleep(delayMs) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, delayMs);
-  });
-}
-function pruneBudgetCoordinators() {
-  const now = Date.now();
-  for (const [key, coordinator] of budgetCoordinators.entries()) {
-    if (coordinator.isExpired(now)) {
-      budgetCoordinators.delete(key);
-    }
-  }
-  while (budgetCoordinators.size > MAX_BUDGET_COORDINATORS) {
-    const evictableEntries = [...budgetCoordinators.entries()].filter(([, coordinator]) => coordinator.isEvictable(now)).sort(
-      ([, leftCoordinator], [, rightCoordinator]) => leftCoordinator.getLastUsedAt() - rightCoordinator.getLastUsedAt()
-    );
-    if (evictableEntries.length === 0) {
-      break;
-    }
-    budgetCoordinators.delete(evictableEntries[0][0]);
-  }
-}
-function getBudgetCoordinator(key) {
-  pruneBudgetCoordinators();
-  let coordinator = budgetCoordinators.get(key);
-  if (!coordinator) {
-    coordinator = new BudgetCoordinator();
-    budgetCoordinators.set(key, coordinator);
-    pruneBudgetCoordinators();
-  }
-  coordinator.touch();
-  return coordinator;
-}
-function hasPacingConfig(rateLimit) {
-  if (!rateLimit || rateLimit.enabled === false) {
-    return false;
-  }
-  return rateLimit.enabled === true || rateLimit.key !== void 0 || rateLimit.cooldownMs !== void 0 || rateLimit.initialDelayMs !== void 0 || rateLimit.maxAttempts !== void 0;
-}
-function normalizeNonNegativeInteger(value, fallback) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return fallback;
-  }
-  return Math.max(0, Math.trunc(value));
-}
-function hashKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-function deriveBudgetKey(options) {
-  const type = options.type;
-  const provider = typeof type === "string" && type ? type : "openai";
-  const credentialLikeValues = [
-    "apiKey" in options ? options.apiKey : void 0,
-    "apiToken" in options ? options.apiToken : void 0,
-    "credentials" in options ? options.credentials?.accessKeyId : void 0,
-    "endpoint" in options ? options.endpoint : void 0,
-    "baseUrl" in options ? options.baseUrl : void 0,
-    "cliPath" in options ? options.cliPath : void 0
-  ];
-  const seed = credentialLikeValues.find(
-    (value) => typeof value === "string" && value.length > 0
-  );
-  return seed ? `${provider}:${hashKey(seed)}` : `${provider}:default`;
-}
-function normalizeRateLimitConfig(options) {
-  const rateLimit = "rateLimit" in options ? options.rateLimit : void 0;
-  if (!hasPacingConfig(rateLimit)) {
-    return null;
-  }
-  return {
-    cooldownMs: normalizeNonNegativeInteger(rateLimit?.cooldownMs, 0),
-    initialDelayMs: normalizeNonNegativeInteger(
-      rateLimit?.initialDelayMs,
-      5e3
-    ),
-    key: rateLimit?.key?.trim() || deriveBudgetKey(options),
-    maxAttempts: Math.max(
-      1,
-      normalizeNonNegativeInteger(rateLimit?.maxAttempts, 1)
-    )
-  };
-}
-function getRetryDelayMs(error, config) {
-  const hintedDelayMs = typeof error.retryAfter === "number" && Number.isFinite(error.retryAfter) ? Math.max(0, Math.ceil(error.retryAfter * 1e3)) : void 0;
-  if (hintedDelayMs !== void 0) {
-    return Math.max(config.cooldownMs, hintedDelayMs);
-  }
-  return Math.max(config.cooldownMs, config.initialDelayMs);
-}
-async function invokeWithPacing(execute, coordinator, config) {
-  let attempt = 1;
-  while (true) {
-    await coordinator.waitUntilReady();
-    try {
-      const result = await execute();
-      coordinator.delayFor(config.cooldownMs);
-      return result;
-    } catch (error) {
-      if (error instanceof RateLimitError) {
-        coordinator.delayFor(getRetryDelayMs(error, config));
-        if (error.retryable && attempt < config.maxAttempts) {
-          attempt += 1;
-          continue;
-        }
-      }
-      throw error;
-    }
-  }
-}
-function parseRetryAfterSeconds(retryAfter) {
-  if (typeof retryAfter === "number" && Number.isFinite(retryAfter)) {
-    return Math.max(0, retryAfter);
-  }
-  if (typeof retryAfter !== "string") {
-    return void 0;
-  }
-  const trimmed = retryAfter.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  const seconds = Number.parseFloat(trimmed);
-  if (!Number.isNaN(seconds)) {
-    return Math.max(0, seconds);
-  }
-  const retryAt = Date.parse(trimmed);
-  if (Number.isNaN(retryAt)) {
-    return void 0;
-  }
-  return Math.max(0, Math.ceil((retryAt - Date.now()) / 1e3));
-}
-function getHeaderValue(headers, headerName) {
-  if (!headers || typeof headers !== "object") {
-    return void 0;
-  }
-  if ("get" in headers && typeof headers.get === "function") {
-    return headers.get(headerName) ?? headers.get(headerName.toLowerCase());
-  }
-  const objectHeaders = headers;
-  return objectHeaders[headerName] ?? objectHeaders[headerName.toLowerCase()];
-}
-function extractRetryAfterSeconds(error) {
-  if (!error || typeof error !== "object") {
-    return void 0;
-  }
-  if ("retryAfter" in error) {
-    const retryAfter = parseRetryAfterSeconds(
-      error.retryAfter
-    );
-    if (retryAfter !== void 0) {
-      return retryAfter;
-    }
-  }
-  if ("headers" in error) {
-    const retryAfter = parseRetryAfterSeconds(
-      getHeaderValue(error.headers, "retry-after")
-    );
-    if (retryAfter !== void 0) {
-      return retryAfter;
-    }
-  }
-  const message = "message" in error && typeof error.message === "string" ? error.message : "";
-  const retryAfterMatch = message.match(/retry after\s+(\d+(?:\.\d+)?)\s*s?/i) ?? message.match(/retryDelay[^\d]*(\d+(?:\.\d+)?)s/i);
-  return retryAfterMatch ? parseRetryAfterSeconds(retryAfterMatch[1]) : void 0;
-}
-function createRateLimitedAI(client, options) {
-  const config = normalizeRateLimitConfig(options);
-  if (!config) {
-    return client;
-  }
-  const wrappedMethods = /* @__PURE__ */ new Map();
-  return new Proxy(client, {
-    get(target, property, receiver) {
-      const value = Reflect.get(target, property, receiver);
-      if (typeof value !== "function") {
-        return value;
-      }
-      if (!RATE_LIMITED_METHODS.has(property)) {
-        if (!wrappedMethods.has(property)) {
-          wrappedMethods.set(property, value.bind(target));
-        }
-        return wrappedMethods.get(property);
-      }
-      if (!wrappedMethods.has(property)) {
-        wrappedMethods.set(property, (...args) => {
-          const coordinator = getBudgetCoordinator(config.key);
-          return coordinator.schedule(
-            () => invokeWithPacing(
-              () => Reflect.apply(value, target, args),
-              coordinator,
-              config
-            )
-          );
-        });
-      }
-      return wrappedMethods.get(property);
-    }
-  });
-}
-const DEFAULT_AI_TIMEOUT_MS = 12e4;
-const DEFAULT_AI_MAX_RETRIES = 0;
-const DEFAULT_AI_GENERATION_LIMITS = Object.freeze({
-  maxOutputTokens: 4096,
-  maxReasoningTokens: 1024,
-  maxImagesPerRequest: 1,
-  onExceeded: "error"
-});
-function positiveInteger(value, fallback, field) {
-  if (value === void 0) return fallback;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new AIError(
-      `${field} must be a positive finite number`,
-      "AI_LIMIT_INVALID"
-    );
-  }
-  return Math.trunc(value);
-}
-function normalizeBaseAIOptions(options) {
-  const configuredLimits = options.generationLimits || {};
-  const generationLimits = {
-    maxOutputTokens: positiveInteger(
-      configuredLimits.maxOutputTokens,
-      DEFAULT_AI_GENERATION_LIMITS.maxOutputTokens,
-      "generationLimits.maxOutputTokens"
-    ),
-    maxReasoningTokens: positiveInteger(
-      configuredLimits.maxReasoningTokens,
-      DEFAULT_AI_GENERATION_LIMITS.maxReasoningTokens,
-      "generationLimits.maxReasoningTokens"
-    ),
-    maxImagesPerRequest: positiveInteger(
-      configuredLimits.maxImagesPerRequest,
-      DEFAULT_AI_GENERATION_LIMITS.maxImagesPerRequest,
-      "generationLimits.maxImagesPerRequest"
-    ),
-    onExceeded: configuredLimits.onExceeded || DEFAULT_AI_GENERATION_LIMITS.onExceeded
-  };
-  if (!["error", "clamp"].includes(generationLimits.onExceeded)) {
-    throw new AIError(
-      'generationLimits.onExceeded must be "error" or "clamp"',
-      "AI_LIMIT_INVALID"
-    );
-  }
-  return {
-    ...options,
-    timeout: positiveInteger(options.timeout, DEFAULT_AI_TIMEOUT_MS, "timeout"),
-    maxRetries: (() => {
-      if (options.maxRetries === void 0) return DEFAULT_AI_MAX_RETRIES;
-      if (!Number.isFinite(options.maxRetries) || options.maxRetries < 0) {
-        throw new AIError(
-          "maxRetries must be a non-negative finite number",
-          "AI_LIMIT_INVALID"
-        );
-      }
-      return Math.trunc(options.maxRetries);
-    })(),
-    generationLimits
-  };
-}
-function reasoningTokensForEffort(effort) {
-  switch (effort) {
-    case false:
-    case "none":
-      return 0;
-    case "minimal":
-      return 1024;
-    case "low":
-      return 2048;
-    case "medium":
-      return 4096;
-    case "high":
-      return 8192;
-    default:
-      return void 0;
-  }
-}
-function enforceLimit(requested, limit, behavior, label, provider, model) {
-  if (!Number.isFinite(requested) || requested < 0) {
-    throw new AIError(
-      `${label} must be a non-negative finite number`,
-      "AI_LIMIT_INVALID",
-      provider,
-      model
-    );
-  }
-  const normalized = Math.trunc(requested);
-  if (normalized <= limit) return normalized;
-  if (behavior === "clamp") return limit;
-  throw new AIError(
-    `${label} ${normalized} exceeds configured ceiling ${limit}`,
-    "AI_LIMIT_EXCEEDED",
-    provider,
-    model
-  );
-}
-function normalizeChatOptions(providerOptions, options, provider, model) {
-  const normalizedProvider = normalizeBaseAIOptions(providerOptions);
-  const limits = normalizedProvider.generationLimits;
-  const requestedOutput = options.maxTokens ?? limits.maxOutputTokens;
-  const legacyEffort = options.thinkingLevel ?? providerOptions.thinkingLevel;
-  const reasoningWasRequested = options.reasoning !== void 0 || legacyEffort !== void 0 || options.includeThoughts === true;
-  const requestedReasoning = reasoningWasRequested ? options.reasoning?.maxTokens ?? reasoningTokensForEffort(options.reasoning?.effort ?? legacyEffort) ?? limits.maxReasoningTokens : 0;
-  return {
-    ...options,
-    maxTokens: enforceLimit(
-      requestedOutput,
-      limits.maxOutputTokens,
-      limits.onExceeded,
-      "maxTokens",
-      provider,
-      model
-    ),
-    reasoning: {
-      ...options.reasoning,
-      maxTokens: enforceLimit(
-        requestedReasoning,
-        limits.maxReasoningTokens,
-        limits.onExceeded,
-        "reasoning.maxTokens",
-        provider,
-        model
-      ),
-      includeThoughts: options.reasoning?.includeThoughts ?? options.includeThoughts
-    }
-  };
-}
-function normalizeImageGenerationOptions(providerOptions, options, provider, model) {
-  const normalizedProvider = normalizeBaseAIOptions(providerOptions);
-  const limits = normalizedProvider.generationLimits;
-  return {
-    ...options,
-    n: enforceLimit(
-      options.n ?? 1,
-      limits.maxImagesPerRequest,
-      limits.onExceeded,
-      "n",
-      provider,
-      model
-    )
-  };
-}
-function prepareRequestControls(providerOptions, requestOptions = {}) {
-  const normalized = normalizeBaseAIOptions(providerOptions);
-  const timeout = positiveInteger(
-    requestOptions.timeout,
-    normalized.timeout,
-    "timeout"
-  );
-  const controller = new AbortController();
-  let timedOut = false;
-  const abortFromCaller = () => controller.abort(requestOptions.signal?.reason);
-  if (requestOptions.signal?.aborted) {
-    abortFromCaller();
-  } else {
-    requestOptions.signal?.addEventListener("abort", abortFromCaller, {
-      once: true
-    });
-  }
-  const timer = setTimeout(() => {
-    timedOut = true;
-    controller.abort(new Error(`AI request timed out after ${timeout}ms`));
-  }, timeout);
-  return {
-    signal: controller.signal,
-    timeout,
-    didTimeout: () => timedOut,
-    cleanup: () => {
-      clearTimeout(timer);
-      requestOptions.signal?.removeEventListener("abort", abortFromCaller);
-    }
-  };
-}
-function mergeTags(providerOptions, callTags) {
-  return providerOptions.usageTags || callTags ? { ...providerOptions.usageTags, ...callTags } : void 0;
-}
-function emitRequestEvent(providerOptions, event) {
-  if (!providerOptions.onRequest) return;
-  try {
-    providerOptions.onRequest({
-      ...event,
-      tags: mergeTags(providerOptions, event.tags)
-    });
-  } catch {
-  }
-}
-function classifyRequestFailure(error, didTimeout = false) {
-  const code = error instanceof AIError ? error.code : void 0;
-  if (code === "AI_LIMIT_EXCEEDED" || code === "AI_LIMIT_INVALID") {
-    return { status: "rejected", errorCode: code };
-  }
-  if (didTimeout || code === "AI_TIMEOUT" || code === "TIMEOUT") {
-    return { status: "timed_out", errorCode: code || "AI_TIMEOUT" };
-  }
-  if (error instanceof Error && error.name === "AbortError") {
-    return { status: "aborted", errorCode: "ABORTED" };
-  }
-  if (code === "AI_ABORTED") {
-    return { status: "aborted", errorCode: code };
-  }
-  return {
-    status: "failed",
-    errorCode: code || (error instanceof Error ? error.name : void 0)
-  };
-}
-function requestEventBase(options) {
-  const normalized = normalizeBaseAIOptions(options.providerOptions);
-  return {
-    provider: options.provider,
-    model: options.model,
-    operation: options.operation,
-    attempts: normalized.maxRetries + 1,
-    requestedMaxOutputTokens: options.callOptions?.maxTokens,
-    effectiveMaxOutputTokens: options.operation === "generateImage" ? void 0 : options.effectiveMaxOutputTokens ?? normalized.generationLimits.maxOutputTokens,
-    tags: options.callOptions?.usageTags
-  };
-}
-const OBSERVED_OPERATIONS = /* @__PURE__ */ new Set([
-  "chat",
-  "complete",
-  "message",
-  "describeImage",
-  "generateImage",
-  "stream"
-]);
-function callOptionsFor(operation, args) {
-  const index = operation === "describeImage" ? 2 : 1;
-  const value = args[index];
-  return value && typeof value === "object" ? value : void 0;
-}
-function providerName(options) {
-  const configured = options.type;
-  return configured || "openai";
-}
-function effectiveOutputTokens(operation, providerOptions, callOptions) {
-  if (operation === "generateImage") {
-    normalizeImageGenerationOptions(
-      providerOptions,
-      callOptions || {},
-      providerName(providerOptions),
-      callOptions?.model
-    );
-    return void 0;
-  }
-  return normalizeChatOptions(
-    providerOptions,
-    callOptions || {},
-    providerName(providerOptions),
-    callOptions?.model || providerOptions.defaultModel
-  ).maxTokens;
-}
-function createObservedAI(client, providerOptions) {
-  if (!providerOptions.onRequest) return client;
-  return new Proxy(client, {
-    get(target, property, receiver) {
-      const value = Reflect.get(target, property, receiver);
-      if (typeof property !== "string" || typeof value !== "function" || !OBSERVED_OPERATIONS.has(property)) {
-        return typeof value === "function" ? value.bind(target) : value;
-      }
-      const operation = property;
-      if (operation === "stream") {
-        return async function* (...args) {
-          const startedAt = Date.now();
-          const callOptions = callOptionsFor(operation, args);
-          let base;
-          try {
-            base = requestEventBase({
-              providerOptions,
-              provider: providerName(providerOptions),
-              model: callOptions?.model || providerOptions.defaultModel || "unknown",
-              operation,
-              callOptions,
-              effectiveMaxOutputTokens: effectiveOutputTokens(
-                operation,
-                providerOptions,
-                callOptions
-              )
-            });
-            const iterable = Reflect.apply(
-              value,
-              target,
-              args
-            );
-            for await (const chunk of iterable) yield chunk;
-            emitRequestEvent(providerOptions, {
-              ...base,
-              status: "succeeded",
-              duration: Date.now() - startedAt
-            });
-          } catch (error) {
-            const failure = classifyRequestFailure(error);
-            base ||= requestEventBase({
-              providerOptions,
-              provider: providerName(providerOptions),
-              model: callOptions?.model || providerOptions.defaultModel || "unknown",
-              operation,
-              callOptions
-            });
-            emitRequestEvent(providerOptions, {
-              ...base,
-              ...failure,
-              duration: Date.now() - startedAt
-            });
-            throw error;
-          }
-        };
-      }
-      return async (...args) => {
-        const startedAt = Date.now();
-        const callOptions = callOptionsFor(operation, args);
-        let base;
-        try {
-          base = requestEventBase({
-            providerOptions,
-            provider: providerName(providerOptions),
-            model: callOptions?.model || providerOptions.defaultModel || "unknown",
-            operation,
-            callOptions,
-            effectiveMaxOutputTokens: effectiveOutputTokens(
-              operation,
-              providerOptions,
-              callOptions
-            )
-          });
-          const result = await Reflect.apply(value, target, args);
-          emitRequestEvent(providerOptions, {
-            ...base,
-            status: "succeeded",
-            duration: Date.now() - startedAt
-          });
-          return result;
-        } catch (error) {
-          const failure = classifyRequestFailure(error);
-          base ||= requestEventBase({
-            providerOptions,
-            provider: providerName(providerOptions),
-            model: callOptions?.model || providerOptions.defaultModel || "unknown",
-            operation,
-            callOptions
-          });
-          emitRequestEvent(providerOptions, {
-            ...base,
-            ...failure,
-            duration: Date.now() - startedAt
-          });
-          throw error;
-        }
-      };
-    }
-  });
-}
-function isOpenAIOptions(options) {
-  return !options.type || options.type === "openai";
-}
-function isLiteLLMOptions(options) {
-  return options.type === "litellm";
-}
-function isBifrostOptions(options) {
-  return options.type === "bifrost";
-}
-function isOllamaOptions(options) {
-  return options.type === "ollama";
-}
-function isGeminiOptions(options) {
-  return options.type === "gemini";
-}
-function isAnthropicOptions(options) {
-  return options.type === "anthropic";
-}
-function isHuggingFaceOptions(options) {
-  return options.type === "huggingface";
-}
-function isBedrockOptions(options) {
-  return options.type === "bedrock";
-}
-function isClaudeCliOptions(options) {
-  return options.type === "claude-cli";
-}
-function isQwen3TTSOptions(options) {
-  return options.type === "qwen3-tts";
-}
-async function getAI(options = {}) {
-  options = loadEnvConfig(options, {
-    packageName: "ai",
-    schema: {
-      provider: "string",
-      type: "string",
-      // Alias for provider
-      model: "string",
-      defaultModel: "string",
-      timeout: "number",
-      maxRetries: "number",
-      apiKey: "string",
-      baseUrl: "string",
-      adminApiKey: "string",
-      adminBaseUrl: "string",
-      adminUrl: "string",
-      adminUser: "string",
-      adminUsername: "string",
-      adminPassword: "string"
-    }
-  });
-  if ("provider" in options && !options.type) {
-    options.type = options.provider;
-  }
-  if ("model" in options && !options.defaultModel) {
-    options.defaultModel = options.model;
-  }
-  options = normalizeBaseAIOptions(options);
-  let client;
-  if (isOpenAIOptions(options)) {
-    const { OpenAIProvider } = await import("./openai-CJEo69jb.js");
-    client = new OpenAIProvider(options);
-  } else if (isLiteLLMOptions(options)) {
-    const { LiteLLMProvider } = await import("./litellm-BMFTYbWc.js");
-    client = new LiteLLMProvider(options);
-  } else if (isBifrostOptions(options)) {
-    const { BifrostProvider } = await import("./bifrost-CEnCsciy.js");
-    client = new BifrostProvider(options);
-  } else if (isOllamaOptions(options)) {
-    const { OllamaProvider } = await import("./ollama-DsGDrA-c.js");
-    client = new OllamaProvider(options);
-  } else if (isGeminiOptions(options)) {
-    const { GeminiProvider } = await import("./gemini-CS56gY0D.js");
-    client = new GeminiProvider(options);
-  } else if (isAnthropicOptions(options)) {
-    const { AnthropicProvider } = await import("./anthropic-2z-82zgr.js");
-    client = new AnthropicProvider(options);
-  } else if (isHuggingFaceOptions(options)) {
-    const { HuggingFaceProvider } = await import("./huggingface-wQSfO5xA.js");
-    client = new HuggingFaceProvider(options);
-  } else if (isBedrockOptions(options)) {
-    const { BedrockProvider } = await import("./bedrock-Dc2eVPUD.js");
-    client = new BedrockProvider(options);
-  } else if (isClaudeCliOptions(options)) {
-    const { ClaudeCliProvider } = await import("./claude-cli-X1ONjE8K.js");
-    client = new ClaudeCliProvider(options);
-  } else if (isQwen3TTSOptions(options)) {
-    const { Qwen3TTSProvider } = await import("./qwen-tts-BLYZ6d9s.js");
-    client = new Qwen3TTSProvider(options);
-  } else {
-    throw new ValidationError("Unsupported AI provider type", {
-      supportedTypes: [...AI_PROVIDER_TYPES],
-      providedType: options.type
-    });
-  }
-  return createObservedAI(createRateLimitedAI(client, options), options);
-}
-async function getAIAuto(options) {
-  const baseUrl = String(options.baseUrl || "");
-  const hasKeepAliveOption = "keepAlive" in options && options.keepAlive !== void 0;
-  if (/((?:localhost|127\.0\.0\.1)(?::11434)?(?:\/(?:api|v1))?|ollama(?:\.com)?(?:\/(?:api|v1))?)\/?$/i.test(
-    baseUrl
-  ) || hasKeepAliveOption) {
-    return getAI({ ...options, type: "ollama" });
-  }
-  if (options.apiKey && !options.type) {
-    return getAI({ ...options, type: "openai" });
-  }
-  if (options.apiToken) {
-    return getAI({ ...options, type: "huggingface" });
-  }
-  if (options.region && options.credentials) {
-    return getAI({ ...options, type: "bedrock" });
-  }
-  if (options.projectId || options.anthropicVersion) {
-    if (options.anthropicVersion) {
-      return getAI({ ...options, type: "anthropic" });
-    }
-    if (options.projectId) {
-      return getAI({ ...options, type: "gemini" });
-    }
-  }
-  throw new ValidationError("Could not auto-detect AI provider from options", {
-    hint: 'Please specify a "type" field in options or provide provider-specific credentials',
-    supportedTypes: [...AI_PROVIDER_TYPES],
-    providedOptions: Object.keys(options)
-  });
-}
-const factory = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  getAI,
-  getAIAuto
-}, Symbol.toStringTag, { value: "Module" }));
-class AIMessage {
-  /**
-   * Original options used to create this message
-   */
-  options;
-  /**
-   * Name of the message sender
-   */
-  name;
-  /**
-   * Content of the message
-   */
-  content;
-  /**
-   * Role of the message sender in the conversation
-   */
-  role;
-  /**
-   * Creates a new AI message
-   *
-   * @param options - Message configuration
-   * @param options.role - Role of the message sender
-   * @param options.content - Content of the message
-   * @param options.name - Name of the message sender
-   */
-  constructor(options) {
-    this.options = options;
-    this.role = options.role;
-    this.content = options.content;
-    this.name = options.name;
-  }
-  /**
-   * Factory method to create a new AI message
-   *
-   * @param options - Message configuration
-   * @param options.thread - Thread this message belongs to
-   * @param options.role - Role of the message sender
-   * @param options.content - Content of the message
-   * @param options.name - Name of the message sender
-   * @returns Promise resolving to a new AIMessage instance
-   */
-  static async create(options) {
-    return new AIMessage(options);
-  }
-}
-class AIThread {
-  /**
-   * AI client instance for this thread
-   */
-  ai;
-  /**
-   * Options used to configure this thread
-   */
-  options;
-  /**
-   * Messages in this conversation thread
-   */
-  messages = [];
-  /**
-   * Reference materials to include in the conversation context
-   */
-  references = {};
-  /**
-   * Creates a new AI thread
-   *
-   * @param options - Thread configuration options
-   */
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Factory method to create and initialize a new AI thread
-   *
-   * @param options - Thread configuration options
-   * @returns Promise resolving to an initialized AIThread
-   */
-  static async create(options) {
-    const thread = new AIThread(options);
-    await thread.initialize();
-    return thread;
-  }
-  /**
-   * Initializes the AI client for this thread
-   */
-  async initialize() {
-    this.ai = await AIClient.create(this.options.ai);
-  }
-  /**
-   * Adds a system message to the conversation
-   *
-   * @param prompt - System message content
-   * @returns Promise resolving to the created AIMessage
-   */
-  async addSystem(prompt) {
-    const message = await AIMessage.create({
-      thread: this,
-      role: "system",
-      name: "system",
-      content: prompt
-    });
-    this.messages.push(message);
-    return message;
-  }
-  /**
-   * Adds a message to the conversation
-   *
-   * @param options - Message options
-   * @param options.role - Role of the message sender
-   * @param options.name - Optional name of the message sender
-   * @param options.content - Content of the message
-   * @returns Promise resolving to the created AIMessage
-   */
-  async add(options) {
-    const message = await AIMessage.create({
-      thread: this,
-      role: options.role,
-      name: options.name || options.role,
-      // Default name to role if not provided
-      content: options.content
-    });
-    this.messages.push(message);
-    return message;
-  }
-  /**
-   * Gets all messages in this thread
-   *
-   * @returns Array of AIMessage objects
-   */
-  get() {
-    return this.messages;
-  }
-  /**
-   * Adds a reference to be included in the conversation context
-   *
-   * @param name - Name of the reference
-   * @param body - Content of the reference
-   */
-  addReference(name, body) {
-    this.references[name] = body;
-  }
-  /**
-   * Assembles the conversation history for sending to the AI
-   * Properly orders system message, references, and conversation messages
-   *
-   * @returns Array of message parameters formatted for the OpenAI API
-   */
-  assembleHistory() {
-    const history = [];
-    const systemMessage = this.messages.find((m) => m.role === "system");
-    if (systemMessage) {
-      history.push({
-        role: systemMessage.role,
-        content: systemMessage.content
-      });
-    }
-    for (const name in this.references) {
-      history.push({
-        role: "user",
-        content: `Reference - ${name}:
-${this.references[name]}`
-      });
-    }
-    this.messages.filter((m) => m.role !== "system").forEach((message) => {
-      history.push({ role: message.role, content: message.content });
-    });
-    return history;
-  }
-  /**
-   * Sends a prompt to the AI and gets a response
-   *
-   * @param prompt - Prompt message to send
-   * @param options - Options for the AI response
-   * @param options.responseFormat - Format for the AI to respond with
-   * @returns Promise resolving to the AI response
-   */
-  async do(prompt, options = {
-    responseFormat: "text"
-  }) {
-    const { responseFormat } = options;
-    const history = this.assembleHistory();
-    const response = await this.ai.textCompletion(prompt, {
-      history,
-      responseFormat: {
-        type: responseFormat === "json" ? "json_object" : "text"
-      }
-    });
-    return response;
-  }
-}
-const PACKAGE_VERSION_INITIALIZED = true;
-export {
-  AIError as A,
-  ContentFilterError as C,
-  DEFAULT_AI_GENERATION_LIMITS as D,
-  ModelNotFoundError as M,
-  OpenAIClient as O,
-  PACKAGE_VERSION_INITIALIZED as P,
-  RateLimitError as R,
-  normalizeImageGenerationOptions as a,
-  normalizeBaseAIOptions as b,
-  ContextLengthError as c,
-  AuthenticationError as d,
-  extractRetryAfterSeconds as e,
-  extractTextContent as f,
-  AIClient as g,
-  AIMessage as h,
-  AIThread as i,
-  AI_PROVIDER_TYPES as j,
-  DEFAULT_AI_MAX_RETRIES as k,
-  DEFAULT_AI_TIMEOUT_MS as l,
-  getAI as m,
-  normalizeChatOptions as n,
-  getAIAuto as o,
-  prepareRequestControls as p,
-  getAIClient as q,
-  getOpenAI as r
-};
-//# sourceMappingURL=index-DCXO0nZA.js.map