@happyvertical/ai 0.89.7 → 0.89.8

package/dist/chunks/src-B091S0I4.js

@@ -1,747 +0,0 @@
-import { n as AI_PROVIDER_TYPES } from "./types-sSecpd_N.js";
-import { t as createRateLimitedAI } from "./rate-limit-C2oPwLGI.js";
-import { a as normalizeBaseAIOptions, i as createObservedAI } from "./safety-ClfpyKEN.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/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";
-}
-/**
-* 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 import("./openai-BuwvBruA.js");
-		client = new OpenAIProvider(options);
-	} else if (isLiteLLMOptions(options)) {
-		const { LiteLLMProvider } = await import("./litellm-nOCNI7Vd.js");
-		client = new LiteLLMProvider(options);
-	} else if (isBifrostOptions(options)) {
-		const { BifrostProvider } = await import("./bifrost-DvYZ3LNf.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, 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-B091S0I4.js.map