@happyvertical/ai 0.89.6 → 0.89.8

package/dist/chunks/src-B3ZLEBD2.js

@@ -0,0 +1,1508 @@
+import { a as ContextLengthError, i as ContentFilterError, n as AI_PROVIDER_TYPES, o as ModelNotFoundError, r as AuthenticationError, s as RateLimitError, t as AIError } from "./types-sSecpd_N.js";
+import { n as extractRetryAfterSeconds, t as createRateLimitedAI } from "./rate-limit-C2oPwLGI.js";
+import { a as normalizeBaseAIOptions, c as prepareRequestControls, i as createObservedAI, o as normalizeChatOptions, s as normalizeImageGenerationOptions } from "./safety-ClfpyKEN.js";
+import { t as emitUsage } from "./usage-C1Y1Nlg4.js";
+import { ApiError, ValidationError, loadEnvConfig } from "@happyvertical/utils";
+import OpenAI from "openai";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/shared/providers/openai.ts
+/**
+* OpenAI provider implementation
+*
+* Provides a standardized interface for interacting with OpenAI's GPT models,
+* including chat completions, text completions, embeddings, and streaming responses.
+* Supports all major OpenAI features including function calling, vision models,
+* and custom fine-tuned models.
+*/
+var openai_exports = /* @__PURE__ */ __exportAll({
+	OpenAIProvider: () => OpenAIProvider,
+	buildTokenLimitRequestFields: () => buildTokenLimitRequestFields,
+	usesCompletionTokenLimit: () => usesCompletionTokenLimit
+});
+/**
+* Determines whether a model uses OpenAI's newer reasoning-model request
+* shape: `max_completion_tokens` in place of `max_tokens`, and no
+* `temperature` parameter at all (a non-default `temperature` is rejected
+* with a 400 error).
+*
+* This applies to the `gpt-5` family (`gpt-5`, `gpt-5-mini`, `gpt-5-nano`,
+* and future `gpt-5*` variants) and the `o`-series reasoning models (`o1`,
+* `o3`, `o4`, and their variants such as `o1-mini`, `o3-mini`, `o4-mini`).
+* See OpenAI's reasoning models guide and the Chat Completions API
+* reference for `max_completion_tokens`:
+* https://platform.openai.com/docs/guides/reasoning
+* https://platform.openai.com/docs/api-reference/chat/create
+*
+* The match is a conservative prefix/family check so future `gpt-5*` and
+* `o1`/`o3`/`o4` variants are covered without needing an allowlist update.
+* Models outside these families (`gpt-4.x`, `gpt-3.5`, etc.) are unaffected
+* and keep sending `max_tokens` and `temperature` as before.
+*
+* Gateway providers (`BifrostProvider`, some `LiteLLMProvider` deployments)
+* route with a vendor-prefixed model id, e.g. `openai/gpt-5-mini` — see
+* `BifrostProvider`'s own `defaultModel: 'openai/gpt-4o-mini'` convention in
+* `bifrost.ts`. Only the final path segment is matched against the family
+* checks so those gateway-routed ids are recognized the same as a bare
+* `gpt-5-mini`.
+*
+* Internal request-shaping helper: exported at module level only so it can
+* be unit-tested directly. It is not re-exported from the package entry
+* point (`src/index.ts`) and is not part of the package's public API.
+*
+* @param model - The model identifier (e.g. `gpt-5-mini`, `openai/gpt-5-mini`, `gpt-4.1-mini`)
+* @returns `true` when the model requires `max_completion_tokens` and rejects `temperature`
+*/
+function usesCompletionTokenLimit(model) {
+	if (!model) return false;
+	const normalized = model.toLowerCase();
+	const lastSegment = normalized.slice(normalized.lastIndexOf("/") + 1);
+	return lastSegment.startsWith("gpt-5") || /^o[134](-|$)/.test(lastSegment);
+}
+/**
+* Builds the output-token-limit and temperature fields for a chat/completion
+* request body, shaped for the given model per {@link usesCompletionTokenLimit}.
+*
+* For models that require it: sends `max_completion_tokens` and omits
+* `max_tokens`, and omits `temperature` entirely (never sends a default
+* value in its place). For all other models: sends `max_tokens` and
+* `temperature` unchanged. Fields whose source value is `undefined` are
+* omitted rather than included as `undefined` keys.
+*
+* Internal request-shaping helper: exported at module level only so it can
+* be unit-tested directly. It is not re-exported from the package entry
+* point (`src/index.ts`) and is not part of the package's public API.
+*/
+function buildTokenLimitRequestFields(model, maxTokens, temperature) {
+	if (usesCompletionTokenLimit(model)) return maxTokens === void 0 ? {} : { max_completion_tokens: maxTokens };
+	return {
+		...maxTokens === void 0 ? {} : { max_tokens: maxTokens },
+		...temperature === void 0 ? {} : { temperature }
+	};
+}
+var 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,
+		videoGeneration: false,
+		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");
+	}
+};
+/**
+* OpenAI provider implementation that handles all interactions with OpenAI's API.
+* Supports GPT models, embeddings, function calling, streaming, and vision capabilities.
+*/
+var OpenAIProvider = class {
+	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),
+				...buildTokenLimitRequestFields(model, options.maxTokens, 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
+		}];
+		return (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
+		})).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);
+		return `data:${response.headers.get("content-type") || "image/png"};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);
+			return (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
+			})).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;
+			}
+			return {
+				images: ((await this.client.images.generate(requestParams, {
+					signal: controls.signal,
+					timeout: controls.timeout
+				})).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
+					};
+				}),
+				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();
+		}
+	}
+	async submitVideoGenerationJob(_options) {
+		throw new AIError(`Video generation is not supported by ${this.profile.providerLabel} provider. Use gemini, byteplus-modelark, or openai-compat-video provider.`, "NOT_IMPLEMENTED", this.profile.providerName);
+	}
+	async getVideoGenerationJob(_handle) {
+		throw new AIError(`Video generation is not supported by ${this.profile.providerLabel} provider. Use gemini, byteplus-modelark, or openai-compat-video provider.`, "NOT_IMPLEMENTED", this.profile.providerName);
+	}
+	async fetchVideoGenerationResult(_handle) {
+		throw new AIError(`Video generation is not supported by ${this.profile.providerLabel} provider. Use gemini, byteplus-modelark, or openai-compat-video provider.`, "NOT_IMPLEMENTED", this.profile.providerName);
+	}
+	async cancelVideoGenerationJob(_handle) {
+		throw new AIError(`Video generation is not supported by ${this.profile.providerLabel} provider. Use gemini, byteplus-modelark, or openai-compat-video provider.`, "NOT_IMPLEMENTED", this.profile.providerName);
+	}
+	async validateVideoGenerationAccess() {
+		throw new AIError(`Video generation is not supported by ${this.profile.providerLabel} provider. Use gemini, byteplus-modelark, or openai-compat-video provider.`, "NOT_IMPLEMENTED", this.profile.providerName);
+	}
+	/**
+	* 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),
+				...buildTokenLimitRequestFields(model, options.maxTokens, 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 {
+			return (await this.client.models.list()).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 };
+	}
+	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;
+		return new AIError(error instanceof Error ? error.message : "Unknown error occurred", "UNKNOWN_ERROR", this.profile.providerName);
+	}
+};
+//#endregion
+//#region src/shared/client.ts
+/**
+* Type guard to check if options are for OpenAI client
+*
+* @param options - Options to check
+* @returns True if options are valid for OpenAI client
+*/
+function isOpenAIClientOptions(options) {
+	return options.type === "openai" && "apiKey" in options && !!options.apiKey;
+}
+/**
+* Type guard to check if value is an AI client instance
+*
+* @param value - Value to check
+* @returns True if value is an AI client instance
+*/
+function isAIClientInstance(value) {
+	return value instanceof AIClient;
+}
+/**
+* Base class for AI clients
+* Provides a common interface for different AI service providers
+*/
+var AIClient = class {
+	/**
+	* 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 } = await Promise.resolve().then(() => factory_exports);
+			return await getAI(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);
+	}
+};
+/**
+* Creates an OpenAI client instance
+*
+* @param options - OpenAI configuration options
+* @returns Promise resolving to an OpenAI client
+*/
+async function getOpenAI(options) {
+	return new OpenAI({
+		apiKey: options.apiKey,
+		baseURL: options.baseUrl
+	});
+}
+/**
+* Client implementation for the OpenAI API
+*/
+var OpenAIClient = 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" }) {
+		return await this.textCompletion(text, options);
+	}
+	/**
+	* 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,
+				...buildTokenLimitRequestFields(model, maxTokens, temperature),
+				n,
+				presence_penalty: presencePenalty,
+				response_format: responseFormat,
+				seed,
+				stop,
+				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,
+			...buildTokenLimitRequestFields(model, maxTokens, temperature),
+			n,
+			presence_penalty: presencePenalty,
+			response_format: responseFormat,
+			seed,
+			stop,
+			stream: false,
+			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;
+	}
+};
+/**
+* Factory function to create and initialize an appropriate AI client
+* Delegates to the modern getAI() factory for all provider types
+*
+* @param options - Client configuration options
+* @returns Promise resolving to an initialized AI client
+* @throws Error if client type is invalid
+*/
+async function getAIClient(options) {
+	const { getAI } = await Promise.resolve().then(() => factory_exports);
+	return await getAI(options);
+}
+//#endregion
+//#region src/shared/factory.ts
+/**
+* Universal factory functions for creating AI provider instances
+* Works in both browser and Node.js environments
+*/
+var factory_exports = /* @__PURE__ */ __exportAll({
+	getAI: () => getAI,
+	getAIAuto: () => getAIAuto
+});
+/**
+* Type guards for provider options
+*/
+/**
+* Checks if the options are for OpenAI provider
+* @param options - The AI provider options to check
+* @returns True if options are for OpenAI provider (including default case)
+*/
+function isOpenAIOptions(options) {
+	return !options.type || options.type === "openai";
+}
+/**
+* Checks if the options are for LiteLLM provider
+* @param options - The AI provider options to check
+* @returns True if options are for LiteLLM provider
+*/
+function isLiteLLMOptions(options) {
+	return options.type === "litellm";
+}
+/**
+* Checks if the options are for Bifrost provider
+* @param options - The AI provider options to check
+* @returns True if options are for Bifrost provider
+*/
+function isBifrostOptions(options) {
+	return options.type === "bifrost";
+}
+/**
+* Checks if the options are for Ollama provider
+* @param options - The AI provider options to check
+* @returns True if options are for Ollama provider
+*/
+function isOllamaOptions(options) {
+	return options.type === "ollama";
+}
+/**
+* Checks if the options are for Google Gemini provider
+* @param options - The AI provider options to check
+* @returns True if options are for Gemini provider
+*/
+function isGeminiOptions(options) {
+	return options.type === "gemini";
+}
+/**
+* Checks if the options are for Anthropic Claude provider
+* @param options - The AI provider options to check
+* @returns True if options are for Anthropic provider
+*/
+function isAnthropicOptions(options) {
+	return options.type === "anthropic";
+}
+/**
+* Checks if the options are for Hugging Face provider
+* @param options - The AI provider options to check
+* @returns True if options are for Hugging Face provider
+*/
+function isHuggingFaceOptions(options) {
+	return options.type === "huggingface";
+}
+/**
+* Checks if the options are for AWS Bedrock provider
+* @param options - The AI provider options to check
+* @returns True if options are for Bedrock provider
+*/
+function isBedrockOptions(options) {
+	return options.type === "bedrock";
+}
+/**
+* Checks if the options are for Claude CLI provider
+* @param options - The AI provider options to check
+* @returns True if options are for Claude CLI provider
+*/
+function isClaudeCliOptions(options) {
+	return options.type === "claude-cli";
+}
+/**
+* Checks if the options are for Qwen3-TTS provider
+* @param options - The AI provider options to check
+* @returns True if options are for Qwen3-TTS provider
+*/
+function isQwen3TTSOptions(options) {
+	return options.type === "qwen3-tts";
+}
+/**
+* Checks if the options are for the OpenAI-compatible video-generation provider
+* @param options - The AI provider options to check
+* @returns True if options are for the openai-compat-video provider
+*/
+function isOpenAICompatVideoOptions(options) {
+	return options.type === "openai-compat-video";
+}
+/**
+* Checks if the options are for the BytePlus ModelArk (Seedance) provider
+* @param options - The AI provider options to check
+* @returns True if options are for the byteplus-modelark provider
+*/
+function isByteplusModelArkOptions(options) {
+	return options.type === "byteplus-modelark";
+}
+/** Checks if options select Seevio's native Seedance task API. */
+function isSeevioOptions(options) {
+	return options.type === "seevio";
+}
+/**
+* Creates an AI provider instance based on the provided options.
+* Universal version that works in both browser and Node.js environments.
+*
+* Supports environment variable configuration using the pattern:
+* - HAVE_AI_PROVIDER → provider type (string)
+* - HAVE_AI_MODEL → defaultModel (string)
+* - HAVE_AI_TIMEOUT → timeout (number)
+* - HAVE_AI_MAX_RETRIES → maxRetries (number)
+* - HAVE_AI_API_KEY → apiKey (string) - fallback if provider-specific key not set
+* - HAVE_AI_BASE_URL → baseUrl (string)
+*
+* User-provided options always take precedence over environment variables.
+*
+* Accepts both GetAIOptions (provider-specific options with literal types)
+* and AIClientOptions (legacy interface with generic string type) for
+* backward compatibility with existing code.
+*
+* @param options - Configuration options for the AI provider. Can be GetAIOptions or AIClientOptions.
+* @returns Promise resolving to an AI provider instance that implements the AIInterface
+* @throws {ValidationError} When the provider type is unsupported or invalid
+*
+* @example
+* ```typescript
+* // Create OpenAI client with explicit options
+* const openai = await getAI({
+*   type: 'openai',
+*   apiKey: process.env.OPENAI_API_KEY!,
+*   defaultModel: 'gpt-4o'
+* });
+*
+* // Or use environment variables (HAVE_AI_PROVIDER=openai, HAVE_AI_API_KEY=sk-...)
+* const client = await getAI({});
+*
+* // Create Anthropic client
+* const anthropic = await getAI({
+*   type: 'anthropic',
+*   apiKey: process.env.ANTHROPIC_API_KEY!,
+*   defaultModel: 'claude-3-5-sonnet-20241022'
+* });
+*
+* // Works with AIClientOptions (legacy interface)
+* const clientOptions: AIClientOptions = { type: 'openai', apiKey: '...' };
+* const legacy = await getAI(clientOptions);
+* ```
+*/
+async function getAI(options = {}) {
+	options = loadEnvConfig(options, {
+		packageName: "ai",
+		schema: {
+			provider: "string",
+			type: "string",
+			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 Promise.resolve().then(() => openai_exports);
+		client = new OpenAIProvider(options);
+	} else if (isLiteLLMOptions(options)) {
+		const { LiteLLMProvider } = await import("./litellm-D8iaHaji.js");
+		client = new LiteLLMProvider(options);
+	} else if (isBifrostOptions(options)) {
+		const { BifrostProvider } = await import("./bifrost-s3K7V8oU.js");
+		client = new BifrostProvider(options);
+	} else if (isOllamaOptions(options)) {
+		const { OllamaProvider } = await import("./ollama-BrB6bjnz.js");
+		client = new OllamaProvider(options);
+	} else if (isGeminiOptions(options)) {
+		const { GeminiProvider } = await import("./gemini-GQdugon1.js");
+		client = new GeminiProvider(options);
+	} else if (isAnthropicOptions(options)) {
+		const { AnthropicProvider } = await import("./anthropic-ByuqC5mC.js");
+		client = new AnthropicProvider(options);
+	} else if (isHuggingFaceOptions(options)) {
+		const { HuggingFaceProvider } = await import("./huggingface-DxPspM6Q.js");
+		client = new HuggingFaceProvider(options);
+	} else if (isBedrockOptions(options)) {
+		const { BedrockProvider } = await import("./bedrock-BeVCmkrS.js");
+		client = new BedrockProvider(options);
+	} else if (isClaudeCliOptions(options)) {
+		const { ClaudeCliProvider } = await import("./claude-cli-BH_C62dV.js");
+		client = new ClaudeCliProvider(options);
+	} else if (isQwen3TTSOptions(options)) {
+		const { Qwen3TTSProvider } = await import("./qwen-tts-CAh1upii.js");
+		client = new Qwen3TTSProvider(options);
+	} else if (isOpenAICompatVideoOptions(options)) {
+		const { OpenAICompatVideoProvider } = await import("./openai-compat-video-DNE1Yvp6.js");
+		client = new OpenAICompatVideoProvider(options);
+	} else if (isByteplusModelArkOptions(options)) {
+		const { ByteplusModelArkProvider } = await import("./byteplus-modelark-DaF0U4n1.js");
+		client = new ByteplusModelArkProvider(options);
+	} else if (isSeevioOptions(options)) {
+		const { SeevioProvider } = await import("./seevio-Bbu_hTUF.js");
+		client = new SeevioProvider(options);
+	} else throw new ValidationError("Unsupported AI provider type", {
+		supportedTypes: [...AI_PROVIDER_TYPES],
+		providedType: options.type
+	});
+	return createObservedAI(createRateLimitedAI(client, options), options);
+}
+/**
+* Browser-compatible auto-detection of AI provider based on available credentials.
+* Does not rely on process.env, making it suitable for browser environments.
+*
+* @param options - Configuration options that may contain provider-specific credentials
+* @returns Promise resolving to an AI provider instance based on detected credentials
+* @throws {ValidationError} When no provider can be detected from the provided options
+*
+* @example
+* ```typescript
+* // Auto-detect OpenAI from apiKey
+* const client1 = await getAIAuto({
+*   apiKey: 'sk-...', // Detected as OpenAI
+*   defaultModel: 'gpt-4o'
+* });
+*
+* // Auto-detect Hugging Face from apiToken
+* const client2 = await getAIAuto({
+*   apiToken: 'hf_...', // Detected as Hugging Face
+*   model: 'microsoft/DialoGPT-medium'
+* });
+*
+* // Auto-detect AWS Bedrock from region and credentials
+* const client3 = await getAIAuto({
+*   region: 'us-east-1',
+*   credentials: {
+*     accessKeyId: 'AKIA...',
+*     secretAccessKey: 'xxx'
+*   }
+* });
+* ```
+*/
+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)
+	});
+}
+//#endregion
+//#region src/shared/message.ts
+/**
+* Represents a message in an AI conversation
+*/
+var AIMessage = 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);
+	}
+};
+//#endregion
+//#region src/shared/thread.ts
+/**
+* Represents a conversation thread with an AI model
+* Manages messages, references, and conversation state
+*/
+var AIThread = 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,
+			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}:\n${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();
+		return await this.ai.textCompletion(prompt, {
+			history,
+			responseFormat: { type: responseFormat === "json" ? "json_object" : "text" }
+		});
+	}
+};
+//#endregion
+//#region src/index.ts
+/** @internal */
+var PACKAGE_VERSION_INITIALIZED = true;
+//#endregion
+export { getAI as a, OpenAIClient as c, OpenAIProvider as d, factory_exports as i, getAIClient as l, AIThread as n, getAIAuto as o, AIMessage as r, AIClient as s, PACKAGE_VERSION_INITIALIZED as t, getOpenAI as u };
+
+//# sourceMappingURL=src-B3ZLEBD2.js.map