@happyvertical/ai 0.74.8

package/dist/chunks/index-BT4thAvS.js

@@ -0,0 +1,934 @@
+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, 3)
+    )
+  };
+}
+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);
+    }
+  });
+}
+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;
+  }
+  let client;
+  if (isOpenAIOptions(options)) {
+    const { OpenAIProvider } = await import("./openai-5snI2diE.js");
+    client = new OpenAIProvider(options);
+  } else if (isLiteLLMOptions(options)) {
+    const { LiteLLMProvider } = await import("./litellm-DhPKa_Jz.js");
+    client = new LiteLLMProvider(options);
+  } else if (isBifrostOptions(options)) {
+    const { BifrostProvider } = await import("./bifrost-3mXtQsTj.js");
+    client = new BifrostProvider(options);
+  } else if (isOllamaOptions(options)) {
+    const { OllamaProvider } = await import("./ollama-Di1ldur0.js");
+    client = new OllamaProvider(options);
+  } else if (isGeminiOptions(options)) {
+    const { GeminiProvider } = await import("./gemini-BfpHXDIQ.js");
+    client = new GeminiProvider(options);
+  } else if (isAnthropicOptions(options)) {
+    const { AnthropicProvider } = await import("./anthropic-BRwbhwIl.js");
+    client = new AnthropicProvider(options);
+  } else if (isHuggingFaceOptions(options)) {
+    const { HuggingFaceProvider } = await import("./huggingface-280qv9iv.js");
+    client = new HuggingFaceProvider(options);
+  } else if (isBedrockOptions(options)) {
+    const { BedrockProvider } = await import("./bedrock-Cf1xUerN.js");
+    client = new BedrockProvider(options);
+  } else if (isClaudeCliOptions(options)) {
+    const { ClaudeCliProvider } = await import("./claude-cli-BrHRfkry.js");
+    client = new ClaudeCliProvider(options);
+  } else if (isQwen3TTSOptions(options)) {
+    const { Qwen3TTSProvider } = await import("./qwen-tts-DgPgdXxG.js");
+    client = new Qwen3TTSProvider(options);
+  } else {
+    throw new ValidationError("Unsupported AI provider type", {
+      supportedTypes: [...AI_PROVIDER_TYPES],
+      providedType: options.type
+    });
+  }
+  return createRateLimitedAI(client, 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,
+  ModelNotFoundError as M,
+  OpenAIClient as O,
+  PACKAGE_VERSION_INITIALIZED as P,
+  RateLimitError as R,
+  ContextLengthError as a,
+  AuthenticationError as b,
+  extractTextContent as c,
+  AIClient as d,
+  extractRetryAfterSeconds as e,
+  AIMessage as f,
+  AIThread as g,
+  AI_PROVIDER_TYPES as h,
+  getAI as i,
+  getAIAuto as j,
+  getAIClient as k,
+  getOpenAI as l
+};
+//# sourceMappingURL=index-BT4thAvS.js.map