@happyvertical/ai 0.80.0 → 0.80.1

package/dist/index.js

@@ -1,24 +1,718 @@
-import { g, A, h, i, j, d, C, c, D, k, l, M, O, P, R, f, m, o, q, r } from "./chunks/index-DCXO0nZA.js";
-export {
-  g as AIClient,
-  A as AIError,
-  h as AIMessageClass,
-  i as AIThread,
-  j as AI_PROVIDER_TYPES,
-  d as AuthenticationError,
-  C as ContentFilterError,
-  c as ContextLengthError,
-  D as DEFAULT_AI_GENERATION_LIMITS,
-  k as DEFAULT_AI_MAX_RETRIES,
-  l as DEFAULT_AI_TIMEOUT_MS,
-  M as ModelNotFoundError,
-  O as OpenAIClient,
-  P as PACKAGE_VERSION_INITIALIZED,
-  R as RateLimitError,
-  f as extractTextContent,
-  m as getAI,
-  o as getAIAuto,
-  q as getAIClient,
-  r as getOpenAI
+import { a as ContextLengthError, c as extractTextContent, i as ContentFilterError, n as AI_PROVIDER_TYPES, o as ModelNotFoundError, r as AuthenticationError, s as RateLimitError, t as AIError } from "./chunks/types-FHs-KbGL.js";
+import { t as createRateLimitedAI } from "./chunks/rate-limit-BwyPGXFW.js";
+import { a as normalizeBaseAIOptions, i as createObservedAI, n as DEFAULT_AI_MAX_RETRIES, r as DEFAULT_AI_TIMEOUT_MS, t as DEFAULT_AI_GENERATION_LIMITS } from "./chunks/safety-CEnoJS6X.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;
 };
-//# sourceMappingURL=index.js.map
+//#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,
+				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;
+	}
+};
+/**
+* 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";
+}
+/**
+* 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 import("./chunks/openai--F38QHiJ.js");
+		client = new OpenAIProvider(options);
+	} else if (isLiteLLMOptions(options)) {
+		const { LiteLLMProvider } = await import("./chunks/litellm-D_Oo9OQ_.js");
+		client = new LiteLLMProvider(options);
+	} else if (isBifrostOptions(options)) {
+		const { BifrostProvider } = await import("./chunks/bifrost-fM9FpW_w.js");
+		client = new BifrostProvider(options);
+	} else if (isOllamaOptions(options)) {
+		const { OllamaProvider } = await import("./chunks/ollama-D4ksOTO8.js");
+		client = new OllamaProvider(options);
+	} else if (isGeminiOptions(options)) {
+		const { GeminiProvider } = await import("./chunks/gemini-Bu7Fke7c.js");
+		client = new GeminiProvider(options);
+	} else if (isAnthropicOptions(options)) {
+		const { AnthropicProvider } = await import("./chunks/anthropic-DA8sdt12.js");
+		client = new AnthropicProvider(options);
+	} else if (isHuggingFaceOptions(options)) {
+		const { HuggingFaceProvider } = await import("./chunks/huggingface-B07_6wHW.js");
+		client = new HuggingFaceProvider(options);
+	} else if (isBedrockOptions(options)) {
+		const { BedrockProvider } = await import("./chunks/bedrock-DDiYFUw0.js");
+		client = new BedrockProvider(options);
+	} else if (isClaudeCliOptions(options)) {
+		const { ClaudeCliProvider } = await import("./chunks/claude-cli-CnJh5KQT.js");
+		client = new ClaudeCliProvider(options);
+	} else if (isQwen3TTSOptions(options)) {
+		const { Qwen3TTSProvider } = await import("./chunks/qwen-tts-DRRbOrhA.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);
+}
+/**
+* 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 { AIClient, AIError, AIMessage as AIMessageClass, AIThread, AI_PROVIDER_TYPES, AuthenticationError, ContentFilterError, ContextLengthError, DEFAULT_AI_GENERATION_LIMITS, DEFAULT_AI_MAX_RETRIES, DEFAULT_AI_TIMEOUT_MS, ModelNotFoundError, OpenAIClient, PACKAGE_VERSION_INITIALIZED, RateLimitError, extractTextContent, getAI, getAIAuto, getAIClient, getOpenAI };
+
+//# sourceMappingURL=index.js.map