@od-oneapp/ai-platform 0.1.0

package/dist/xai-CbV_dCnP.mjs

@@ -0,0 +1,1600 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { A as createOpenAI, D as createGoogleGenerativeAI, I as createXai, T as createAnthropic, Wt as xai, at as google, h as anthropic, j as createOpenAICompatible, vt as openai } from "./ai-runtime-CDzQztTt.mjs";
+import { i as getModelMetadata, n as Model, r as getModelId, t as MODEL_METADATA } from "./registry-CsD3iTIx.mjs";
+
+//#region src/models/provider-factory.ts
+/**
+* Creates an AI SDK LanguageModel instance for a semantic model name.
+*
+* By default, routes through the configured gateway (AI_GATEWAY env var).
+* Use `useNative: true` to bypass gateway and connect directly to the provider.
+*
+* @param model - Semantic model name from the {@link Model} enum
+* @param options - Optional configuration for gateway routing
+* @returns AI SDK LanguageModel instance ready for use with generateText/streamText
+*
+* @example
+* ```ts
+* // Uses gateway (default)
+* const model = createLanguageModel(Model.SONNET);
+* const { text } = await generateText({ model, prompt: "Hello" });
+* ```
+*
+* @example
+* ```ts
+* // Bypass gateway for direct provider connection
+* const model = createLanguageModel(Model.SONNET, { useNative: true });
+* ```
+*/
+function createLanguageModel(model, options) {
+	const modelId = getModelId(model);
+	const metadata = getModelMetadata(model);
+	const useNative = options?.useNative ?? false;
+	const configuredGateway = process.env.AI_GATEWAY;
+	if (!useNative && configuredGateway) {
+		if (configuredGateway === "cloudflare") return getCloudflareProvider(model);
+		if (configuredGateway === "vercel") return getVercelGatewayProvider(model);
+	}
+	switch (metadata.provider) {
+		case "anthropic": return anthropic(modelId);
+		case "openai": return openai(modelId);
+		case "google": return google(modelId);
+		case "xai": return createXai()(modelId);
+		case "perplexity": {
+			const apiKey = process.env.PERPLEXITY_API_KEY;
+			if (!apiKey) throw new Error("PERPLEXITY_API_KEY is required for Perplexity provider");
+			return createOpenAICompatible({
+				name: "perplexity",
+				baseURL: "https://api.perplexity.ai",
+				apiKey
+			})(modelId);
+		}
+		default: throw new Error(`Unsupported provider: ${metadata.provider}`);
+	}
+}
+/**
+* Get model through Cloudflare AI Gateway
+*/
+function getCloudflareProvider(model) {
+	const modelId = getModelId(model);
+	const metadata = getModelMetadata(model);
+	const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+	const gatewayName = process.env.CLOUDFLARE_AI_GATEWAY_NAME || "ai-gateway";
+	if (!accountId) throw new Error("CLOUDFLARE_ACCOUNT_ID required for Cloudflare gateway");
+	const baseURL = `https://gateway.ai.cloudflare.com/v1/${accountId}/${gatewayName}/${metadata.provider}`;
+	switch (metadata.provider) {
+		case "anthropic": return createAnthropic({ baseURL })(modelId);
+		case "openai": return createOpenAI({ baseURL })(modelId);
+		case "google": return createGoogleGenerativeAI({ baseURL })(modelId);
+		case "perplexity":
+		case "xai": throw new Error(`Cloudflare gateway not supported for ${metadata.provider}`);
+		default: throw new Error(`Cloudflare gateway not supported for ${metadata.provider}`);
+	}
+}
+/**
+* Get model through Vercel AI Gateway
+*/
+function getVercelGatewayProvider(model) {
+	const modelId = getModelId(model);
+	const metadata = getModelMetadata(model);
+	const apiKey = process.env.AI_GATEWAY_API_KEY;
+	const baseURL = process.env.AI_GATEWAY_BASE_URL || "https://gateway.ai.vercel.com";
+	if (!apiKey) throw new Error("AI_GATEWAY_API_KEY required for Vercel gateway");
+	switch (metadata.provider) {
+		case "anthropic": return createAnthropic({
+			baseURL,
+			apiKey,
+			headers: { "x-api-key": apiKey }
+		})(modelId);
+		case "openai": return createOpenAI({
+			baseURL,
+			apiKey,
+			headers: { "x-api-key": apiKey }
+		})(modelId);
+		case "google":
+		case "perplexity":
+		case "xai": throw new Error(`Vercel gateway not supported for ${metadata.provider}`);
+		default: throw new Error(`Vercel gateway not supported for ${metadata.provider}`);
+	}
+}
+/**
+* Returns all models classified under a given performance tier.
+*
+* @param tier - The tier to filter by (e.g., 'fast', 'balanced', 'powerful')
+* @returns Array of Model enum values matching the tier
+*/
+function getModelsByTier(tier) {
+	return Object.entries(MODEL_METADATA).filter(([, metadata]) => metadata.tier === tier).map(([model]) => model);
+}
+/**
+* Get the tier classification for a model
+*
+* @param model - Semantic model name
+* @returns Model tier classification
+*/
+function getModelTier(model) {
+	return getModelMetadata(model).tier;
+}
+/**
+* Estimate cost for a generation based on token usage
+*
+* @param model - Semantic model name
+* @param inputTokens - Number of input tokens
+* @param outputTokens - Number of output tokens
+* @returns Estimated cost in USD
+*/
+function estimateCost(model, inputTokens, outputTokens) {
+	const metadata = getModelMetadata(model);
+	return inputTokens / 1e3 * metadata.costPer1kInput + outputTokens / 1e3 * metadata.costPer1kOutput;
+}
+/**
+* Finds the cheapest model that satisfies the given capability requirements.
+*
+* @param options - Required capabilities and constraints
+* @returns The least expensive Model matching all requirements
+* @throws Error if no models satisfy the requirements
+*/
+function getCheapestModel(options) {
+	const candidates = Object.entries(MODEL_METADATA).filter(([, metadata]) => {
+		if (options.supportsTools && !metadata.supportsTools) return false;
+		if (options.supportsStreaming && !metadata.supportsStreaming) return false;
+		if (options.minContextWindow !== void 0 && metadata.contextWindow < options.minContextWindow) return false;
+		return true;
+	}).sort((a, b) => a[1].costPer1kInput - b[1].costPer1kInput);
+	if (candidates.length === 0) throw new Error("No models match the specified requirements");
+	const [model] = candidates[0] ?? [];
+	if (!model) throw new Error("No models match the specified requirements");
+	return model;
+}
+
+//#endregion
+//#region src/models/providers/shared.ts
+/**
+* @fileoverview Shared provider utilities
+*
+* Common constants and helpers used across all AI providers.
+* Single source of truth for temperature, token, and topP presets.
+*
+* @module @od-oneapp/ai-platform/models/providers/shared
+*/
+/**
+* Common temperature presets used across providers.
+*/
+const TEMPS = {
+	PRECISE: 0,
+	VERY_LOW: .1,
+	FACTUAL: .2,
+	LOW_CREATIVE: .3,
+	MODERATE: .5,
+	BALANCED: .7,
+	HIGH_CREATIVE: .8,
+	CREATIVE: .9
+};
+/**
+* Common token limit presets.
+*/
+const TOKENS = {
+	TINY: 256,
+	SHORT: 1024,
+	MEDIUM: 2048,
+	LONG: 4096,
+	EXTENDED: 8192,
+	MAX: 16384
+};
+/**
+* Common topP values for nucleus sampling.
+*/
+const TOP_P = {
+	DETERMINISTIC: 1,
+	FOCUSED: .95,
+	BALANCED: .98
+};
+/**
+* Common mode configurations shared across providers.
+*/
+const commonModes = {
+	precise: () => ({
+		temperature: TEMPS.PRECISE,
+		topP: TOP_P.DETERMINISTIC
+	}),
+	code: () => ({
+		temperature: TEMPS.FACTUAL,
+		topP: TOP_P.FOCUSED
+	}),
+	creative: () => ({
+		temperature: TEMPS.CREATIVE,
+		topP: TOP_P.BALANCED
+	}),
+	research: () => ({
+		temperature: TEMPS.FACTUAL,
+		maxOutputTokens: TOKENS.LONG
+	}),
+	quick: () => ({
+		temperature: TEMPS.MODERATE,
+		maxOutputTokens: TOKENS.SHORT
+	})
+};
+
+//#endregion
+//#region src/models/providers/anthropic.ts
+/**
+* @fileoverview Anthropic provider configuration
+*
+* Provider-specific model IDs, option helpers, capability detection,
+* and metadata extraction for Anthropic Claude models.
+*
+* All AI SDK imports come from the shared module.
+*
+* @module @od-oneapp/ai-platform/models/providers/anthropic
+*/
+var anthropic_exports = /* @__PURE__ */ __exportAll({
+	ANTHROPIC_MODEL_CAPABILITIES: () => ANTHROPIC_MODEL_CAPABILITIES,
+	ANTHROPIC_MODEL_GROUPS: () => ANTHROPIC_MODEL_GROUPS,
+	ANTHROPIC_MODEL_IDS: () => ANTHROPIC_MODEL_IDS,
+	ANTHROPIC_PRESETS: () => ANTHROPIC_PRESETS,
+	ANTHROPIC_TOOL_NAMES: () => ANTHROPIC_TOOL_NAMES,
+	anthropic: () => anthropic,
+	anthropicTools: () => anthropicTools,
+	extractCacheMetadata: () => extractCacheMetadata,
+	extractProviderMetadata: () => extractProviderMetadata$1,
+	extractReasoningDetails: () => extractReasoningDetails,
+	extractToolErrors: () => extractToolErrors,
+	getCacheMinTokens: () => getCacheMinTokens,
+	getMaxContextTokens: () => getMaxContextTokens,
+	isMultimodalModel: () => isMultimodalModel,
+	isReasoningModel: () => isReasoningModel$1,
+	supportsCodeExecution: () => supportsCodeExecution,
+	supportsComputerUse: () => supportsComputerUse,
+	supportsPDF: () => supportsPDF,
+	supportsReasoning: () => supportsReasoning,
+	supportsWebSearch: () => supportsWebSearch$1,
+	withCacheControl: () => withCacheControl,
+	withExtendedCache: () => withExtendedCache,
+	withReasoning: () => withReasoning,
+	withSendReasoning: () => withSendReasoning
+});
+/** Single source of truth for Anthropic model IDs. */
+const ANTHROPIC_MODEL_IDS = {
+	OPUS_4: "claude-opus-4-20250514",
+	SONNET_4: "claude-sonnet-4-20250514",
+	SONNET_37: "claude-3-7-sonnet-20250219",
+	SONNET_35: "claude-3-5-sonnet-20241022",
+	SONNET_35_OLD: "claude-3-5-sonnet-20240620",
+	HAIKU_35: "claude-3-5-haiku-20241022",
+	OPUS_3: "claude-3-opus-20240229",
+	SONNET_3: "claude-3-sonnet-20240229",
+	HAIKU_3: "claude-3-haiku-20240307"
+};
+/** Model groups for categorization. */
+const ANTHROPIC_MODEL_GROUPS = {
+	REASONING_MODELS: [
+		ANTHROPIC_MODEL_IDS.OPUS_4,
+		ANTHROPIC_MODEL_IDS.SONNET_4,
+		ANTHROPIC_MODEL_IDS.SONNET_37
+	],
+	MULTIMODAL_MODELS: [
+		ANTHROPIC_MODEL_IDS.OPUS_4,
+		ANTHROPIC_MODEL_IDS.SONNET_4,
+		ANTHROPIC_MODEL_IDS.SONNET_37,
+		ANTHROPIC_MODEL_IDS.SONNET_35,
+		ANTHROPIC_MODEL_IDS.SONNET_35_OLD,
+		ANTHROPIC_MODEL_IDS.HAIKU_35,
+		ANTHROPIC_MODEL_IDS.OPUS_3,
+		ANTHROPIC_MODEL_IDS.SONNET_3,
+		ANTHROPIC_MODEL_IDS.HAIKU_3
+	],
+	PDF_CAPABLE_MODELS: [ANTHROPIC_MODEL_IDS.SONNET_35],
+	COMPUTER_USE_MODELS: [
+		ANTHROPIC_MODEL_IDS.OPUS_4,
+		ANTHROPIC_MODEL_IDS.SONNET_4,
+		ANTHROPIC_MODEL_IDS.SONNET_37,
+		ANTHROPIC_MODEL_IDS.SONNET_35
+	],
+	WEB_SEARCH_MODELS: [
+		ANTHROPIC_MODEL_IDS.OPUS_4,
+		ANTHROPIC_MODEL_IDS.SONNET_4,
+		ANTHROPIC_MODEL_IDS.SONNET_37,
+		ANTHROPIC_MODEL_IDS.SONNET_35,
+		ANTHROPIC_MODEL_IDS.SONNET_35_OLD,
+		ANTHROPIC_MODEL_IDS.HAIKU_35
+	],
+	CODE_EXECUTION_MODELS: [
+		ANTHROPIC_MODEL_IDS.OPUS_4,
+		ANTHROPIC_MODEL_IDS.SONNET_4,
+		ANTHROPIC_MODEL_IDS.SONNET_37,
+		ANTHROPIC_MODEL_IDS.SONNET_35,
+		ANTHROPIC_MODEL_IDS.SONNET_35_OLD,
+		ANTHROPIC_MODEL_IDS.HAIKU_35
+	]
+};
+/** Per-model capability mapping. */
+const ANTHROPIC_MODEL_CAPABILITIES = {
+	[ANTHROPIC_MODEL_IDS.OPUS_4]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: true,
+		webSearch: true,
+		codeExecution: true,
+		pdfSupport: false,
+		reasoningText: true,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 1024,
+		specialFeatures: [
+			"reasoning",
+			"computer-use",
+			"web-search",
+			"code-execution"
+		]
+	},
+	[ANTHROPIC_MODEL_IDS.SONNET_4]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: true,
+		webSearch: true,
+		codeExecution: true,
+		pdfSupport: false,
+		reasoningText: true,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 1024,
+		specialFeatures: [
+			"reasoning",
+			"computer-use",
+			"web-search",
+			"code-execution"
+		]
+	},
+	[ANTHROPIC_MODEL_IDS.SONNET_37]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: true,
+		webSearch: true,
+		codeExecution: true,
+		pdfSupport: false,
+		reasoningText: true,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 1024,
+		specialFeatures: [
+			"reasoning",
+			"computer-use",
+			"web-search",
+			"code-execution"
+		]
+	},
+	[ANTHROPIC_MODEL_IDS.SONNET_35]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: true,
+		webSearch: true,
+		codeExecution: true,
+		pdfSupport: true,
+		reasoningText: false,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 1024,
+		specialFeatures: [
+			"pdf-support",
+			"computer-use",
+			"web-search",
+			"code-execution"
+		]
+	},
+	[ANTHROPIC_MODEL_IDS.SONNET_35_OLD]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: false,
+		webSearch: true,
+		codeExecution: true,
+		pdfSupport: false,
+		reasoningText: false,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 1024,
+		specialFeatures: ["web-search", "code-execution"]
+	},
+	[ANTHROPIC_MODEL_IDS.HAIKU_35]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: false,
+		webSearch: true,
+		codeExecution: true,
+		pdfSupport: false,
+		reasoningText: false,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 2048,
+		specialFeatures: [
+			"fast",
+			"web-search",
+			"code-execution"
+		]
+	},
+	[ANTHROPIC_MODEL_IDS.OPUS_3]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: false,
+		webSearch: false,
+		codeExecution: false,
+		pdfSupport: false,
+		reasoningText: false,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 1024,
+		specialFeatures: ["legacy"]
+	},
+	[ANTHROPIC_MODEL_IDS.SONNET_3]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: false,
+		webSearch: false,
+		codeExecution: false,
+		pdfSupport: false,
+		reasoningText: false,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 1024,
+		specialFeatures: ["legacy"]
+	},
+	[ANTHROPIC_MODEL_IDS.HAIKU_3]: {
+		imageInput: true,
+		objectGeneration: true,
+		toolUsage: true,
+		computerUse: false,
+		webSearch: false,
+		codeExecution: false,
+		pdfSupport: false,
+		reasoningText: false,
+		maxContextTokens: 2e5,
+		cacheMinTokens: 2048,
+		specialFeatures: ["legacy", "fast"]
+	}
+};
+/** Configuration presets for common use cases. */
+const ANTHROPIC_PRESETS = {
+	REASONING: {
+		temperature: TEMPS.PRECISE,
+		maxOutputTokens: TOKENS.LONG,
+		topP: TOP_P.FOCUSED,
+		anthropic: { sendReasoning: true }
+	},
+	CREATIVE: {
+		temperature: TEMPS.CREATIVE,
+		maxOutputTokens: TOKENS.MEDIUM,
+		topP: TOP_P.BALANCED
+	},
+	CODING: {
+		temperature: TEMPS.BALANCED,
+		maxOutputTokens: TOKENS.EXTENDED,
+		topP: TOP_P.DETERMINISTIC
+	},
+	ANALYSIS: {
+		temperature: TEMPS.VERY_LOW,
+		maxOutputTokens: TOKENS.LONG,
+		topP: TOP_P.FOCUSED
+	},
+	VISION: {
+		temperature: TEMPS.BALANCED,
+		maxOutputTokens: TOKENS.MEDIUM,
+		topP: TOP_P.BALANCED
+	},
+	QUICK: {
+		temperature: TEMPS.VERY_LOW,
+		maxOutputTokens: TOKENS.SHORT,
+		topP: TOP_P.DETERMINISTIC
+	}
+};
+/** Anthropic tool name constants. */
+const ANTHROPIC_TOOL_NAMES = {
+	WEB_SEARCH: "web_search",
+	CODE_EXECUTION: "code_execution",
+	COMPUTER: "computer",
+	BASH: "bash",
+	TEXT_EDITOR: "str_replace_editor",
+	TEXT_EDITOR_V2: "str_replace_based_edit_tool"
+};
+/** Anthropic-specific tool helpers wrapping SDK native tools. */
+const anthropicTools = {
+	webSearch: (options) => anthropic.tools.webSearch_20250305(options ?? { maxUses: 5 }),
+	codeExecution: () => anthropic.tools.codeExecution_20250522(),
+	computer: (config) => anthropic.tools.computer_20241022({
+		displayWidthPx: config.displayWidth ?? 1920,
+		displayHeightPx: config.displayHeight ?? 1080
+	}),
+	bash: () => anthropic.tools.bash_20241022({}),
+	textEditor: () => anthropic.tools.textEditor_20241022({}),
+	textEditorV2: () => anthropic.tools.textEditor_20250429({})
+};
+/** Enable reasoning/thinking mode for Claude 4 and 3.7 models. */
+function withReasoning(budgetTokens = 12e3) {
+	return { providerOptions: { anthropic: { thinking: {
+		type: "enabled",
+		budgetTokens
+	} } } };
+}
+/** Configure cache control for prompt caching. */
+function withCacheControl(ttl) {
+	return { providerOptions: { anthropic: { cacheControl: {
+		type: "ephemeral",
+		...ttl && { ttl }
+	} } } };
+}
+/** Control whether reasoning content is sent in requests. */
+function withSendReasoning(send = true) {
+	return { providerOptions: { anthropic: { sendReasoning: send } } };
+}
+/** Extended cache with 1-hour TTL (requires beta header). */
+function withExtendedCache() {
+	return {
+		headers: { "anthropic-beta": "extended-cache-ttl-2025-04-11" },
+		providerOptions: { anthropic: { cacheControl: {
+			type: "ephemeral",
+			ttl: "1h"
+		} } }
+	};
+}
+function getModelCapabilities$1(modelId) {
+	return ANTHROPIC_MODEL_CAPABILITIES[modelId];
+}
+/** Check if model supports reasoning/thinking. */
+function supportsReasoning(modelId) {
+	return getModelCapabilities$1(modelId)?.reasoningText ?? false;
+}
+/** Check if model supports PDF input. */
+function supportsPDF(modelId) {
+	return getModelCapabilities$1(modelId)?.pdfSupport ?? false;
+}
+/** Check if model supports computer use. */
+function supportsComputerUse(modelId) {
+	return getModelCapabilities$1(modelId)?.computerUse ?? false;
+}
+/** Check if model supports web search. */
+function supportsWebSearch$1(modelId) {
+	return getModelCapabilities$1(modelId)?.webSearch ?? false;
+}
+/** Check if model supports code execution. */
+function supportsCodeExecution(modelId) {
+	return getModelCapabilities$1(modelId)?.codeExecution ?? false;
+}
+/** Get minimum cacheable tokens for a model. */
+function getCacheMinTokens(modelId) {
+	return getModelCapabilities$1(modelId)?.cacheMinTokens ?? 1024;
+}
+/** Get maximum context tokens for a model. */
+function getMaxContextTokens(modelId) {
+	return getModelCapabilities$1(modelId)?.maxContextTokens ?? 2e5;
+}
+/** Check if model is a reasoning model. */
+function isReasoningModel$1(modelId) {
+	return ANTHROPIC_MODEL_GROUPS.REASONING_MODELS.includes(modelId);
+}
+/** Check if model is multimodal (supports images). */
+function isMultimodalModel(modelId) {
+	return ANTHROPIC_MODEL_GROUPS.MULTIMODAL_MODELS.includes(modelId);
+}
+/** Extract reasoning details from a generation result. */
+function extractReasoningDetails(result) {
+	const anthropicMeta = result.providerOptions?.anthropic;
+	if (!anthropicMeta || typeof anthropicMeta !== "object" || Array.isArray(anthropicMeta)) return null;
+	const reasoningDetails = anthropicMeta.reasoningText;
+	if (!reasoningDetails || typeof reasoningDetails !== "object" || Array.isArray(reasoningDetails)) return null;
+	const { reasoningContent } = reasoningDetails;
+	return {
+		reasoningText: typeof reasoningContent === "string" ? reasoningContent : "",
+		reasoningDetails
+	};
+}
+/** Extract cache metadata from a generation result. */
+function extractCacheMetadata(result) {
+	const anthropicMeta = result.providerOptions?.anthropic;
+	if (!anthropicMeta || typeof anthropicMeta !== "object" || Array.isArray(anthropicMeta)) return null;
+	const { cacheCreationInputTokens, cacheReadInputTokens } = anthropicMeta;
+	return {
+		cacheCreationInputTokens: typeof cacheCreationInputTokens === "number" ? cacheCreationInputTokens : 0,
+		cacheReadInputTokens: typeof cacheReadInputTokens === "number" ? cacheReadInputTokens : 0
+	};
+}
+/** Extract complete Anthropic provider metadata. */
+function extractProviderMetadata$1(result) {
+	const anthropicMeta = result.providerOptions?.anthropic;
+	if (!anthropicMeta || typeof anthropicMeta !== "object" || Array.isArray(anthropicMeta)) return null;
+	const meta = anthropicMeta;
+	const reasoningDetails = meta.reasoningText;
+	const { cacheCreationInputTokens, cacheReadInputTokens } = meta;
+	return {
+		cacheCreationInputTokens: typeof cacheCreationInputTokens === "number" ? cacheCreationInputTokens : 0,
+		cacheReadInputTokens: typeof cacheReadInputTokens === "number" ? cacheReadInputTokens : 0,
+		reasoningText: result.reasoningText,
+		reasoningDetails: reasoningDetails && typeof reasoningDetails === "object" && !Array.isArray(reasoningDetails) ? reasoningDetails : void 0
+	};
+}
+/** Extract tool errors from generation results. */
+function extractToolErrors(result) {
+	const errors = [];
+	if (result.content && Array.isArray(result.content)) result.content.forEach((part) => {
+		if (part.type === "tool-error") errors.push({
+			toolName: part.toolName ?? "unknown",
+			toolCallId: part.toolCallId ?? "",
+			error: part.error
+		});
+	});
+	return errors;
+}
+
+//#endregion
+//#region src/models/providers/openai.ts
+/**
+* @fileoverview OpenAI provider configuration
+*
+* Provider-specific model IDs, option helpers, capability detection,
+* and metadata extraction for OpenAI models.
+*
+* All AI SDK imports come from the shared module.
+*
+* @module @od-oneapp/ai-platform/models/providers/openai
+*/
+var openai_exports = /* @__PURE__ */ __exportAll({
+	OPENAI_MODEL_GROUPS: () => OPENAI_MODEL_GROUPS,
+	OPENAI_MODEL_IDS: () => OPENAI_MODEL_IDS,
+	OPENAI_PRESETS: () => OPENAI_PRESETS,
+	createOpenAI: () => createOpenAI,
+	extractCachedPromptTokens: () => extractCachedPromptTokens,
+	extractOpenAIMetadata: () => extractOpenAIMetadata,
+	extractPredictionTokens: () => extractPredictionTokens,
+	extractReasoningTokens: () => extractReasoningTokens,
+	openai: () => openai,
+	supportsPromptCaching: () => supportsPromptCaching,
+	supportsReasoningMode: () => supportsReasoningMode,
+	supportsServiceTier: () => supportsServiceTier,
+	supportsStructuredOutputs: () => supportsStructuredOutputs,
+	withPredictedOutput: () => withPredictedOutput,
+	withPromptCache: () => withPromptCache,
+	withReasoningMode: () => withReasoningMode,
+	withServiceTier: () => withServiceTier,
+	withStrictMode: () => withStrictMode,
+	withStructuredOutput: () => withStructuredOutput
+});
+/** Single source of truth for OpenAI model IDs. */
+const OPENAI_MODEL_IDS = {
+	GPT_5: "gpt-5",
+	GPT_5_MINI: "gpt-5-mini",
+	GPT_5_NANO: "gpt-5-nano",
+	GPT_5_CHAT_LATEST: "gpt-5-chat-latest",
+	GPT_41: "gpt-4.1",
+	GPT_41_MINI: "gpt-4.1-mini",
+	GPT_41_NANO: "gpt-4.1-nano",
+	GPT_4O: "gpt-4o",
+	GPT_4O_LATEST: "chatgpt-4o-latest",
+	GPT_4O_MINI: "gpt-4o-mini",
+	GPT_4O_AUDIO: "gpt-4o-audio-preview",
+	GPT_4O_REALTIME: "gpt-4o-realtime-preview",
+	GPT_4_TURBO: "gpt-4-turbo",
+	GPT_4: "gpt-4",
+	GPT_4_32K: "gpt-4-32k",
+	GPT_35_TURBO: "gpt-3.5-turbo",
+	GPT_35_TURBO_INSTRUCT: "gpt-3.5-turbo-instruct",
+	O1: "o1",
+	O1_MINI: "o1-mini",
+	O1_PREVIEW: "o1-preview",
+	O3: "o3",
+	O3_MINI: "o3-mini",
+	O4_MINI: "o4-mini",
+	CODEX_MINI_LATEST: "codex-mini-latest",
+	COMPUTER_USE_PREVIEW: "computer-use-preview",
+	WHISPER_1: "whisper-1",
+	GPT_4O_MINI_TRANSCRIBE: "gpt-4o-mini-transcribe",
+	GPT_4O_TRANSCRIBE: "gpt-4o-transcribe",
+	TTS_1: "tts-1",
+	TTS_1_HD: "tts-1-hd",
+	GPT_4O_MINI_TTS: "gpt-4o-mini-tts",
+	GPT_IMAGE_1: "gpt-image-1",
+	DALL_E_3: "dall-e-3",
+	DALL_E_2: "dall-e-2",
+	EMBEDDING_3_SMALL: "text-embedding-3-small",
+	EMBEDDING_3_LARGE: "text-embedding-3-large",
+	EMBEDDING_ADA_002: "text-embedding-ada-002",
+	MODERATION_LATEST: "text-moderation-latest",
+	MODERATION_STABLE: "text-moderation-stable"
+};
+/** Model groups for categorization. */
+const OPENAI_MODEL_GROUPS = {
+	REASONING_MODELS: [
+		OPENAI_MODEL_IDS.O1,
+		OPENAI_MODEL_IDS.O1_MINI,
+		OPENAI_MODEL_IDS.O1_PREVIEW,
+		OPENAI_MODEL_IDS.O3,
+		OPENAI_MODEL_IDS.O3_MINI,
+		OPENAI_MODEL_IDS.O4_MINI,
+		OPENAI_MODEL_IDS.CODEX_MINI_LATEST,
+		OPENAI_MODEL_IDS.COMPUTER_USE_PREVIEW
+	],
+	GPT5_FAMILY: [
+		OPENAI_MODEL_IDS.GPT_5,
+		OPENAI_MODEL_IDS.GPT_5_MINI,
+		OPENAI_MODEL_IDS.GPT_5_NANO,
+		OPENAI_MODEL_IDS.GPT_5_CHAT_LATEST
+	],
+	CHAT_MODELS: [
+		OPENAI_MODEL_IDS.GPT_5,
+		OPENAI_MODEL_IDS.GPT_5_MINI,
+		OPENAI_MODEL_IDS.GPT_5_NANO,
+		OPENAI_MODEL_IDS.GPT_5_CHAT_LATEST,
+		OPENAI_MODEL_IDS.GPT_4O,
+		OPENAI_MODEL_IDS.GPT_4O_MINI,
+		OPENAI_MODEL_IDS.GPT_4_TURBO,
+		OPENAI_MODEL_IDS.GPT_41,
+		OPENAI_MODEL_IDS.GPT_41_MINI,
+		OPENAI_MODEL_IDS.GPT_4,
+		OPENAI_MODEL_IDS.GPT_4_32K,
+		OPENAI_MODEL_IDS.GPT_35_TURBO
+	],
+	VISION_MODELS: [
+		OPENAI_MODEL_IDS.GPT_4O,
+		OPENAI_MODEL_IDS.GPT_4O_MINI,
+		OPENAI_MODEL_IDS.GPT_4_TURBO,
+		OPENAI_MODEL_IDS.GPT_41,
+		OPENAI_MODEL_IDS.GPT_41_MINI,
+		OPENAI_MODEL_IDS.GPT_5,
+		OPENAI_MODEL_IDS.GPT_5_MINI
+	],
+	LEGACY_MODELS: [
+		OPENAI_MODEL_IDS.GPT_4,
+		OPENAI_MODEL_IDS.GPT_4_32K,
+		OPENAI_MODEL_IDS.GPT_35_TURBO,
+		OPENAI_MODEL_IDS.GPT_35_TURBO_INSTRUCT
+	]
+};
+/** Structured output mode with optional strict JSON schema. */
+function withStructuredOutput(responseFormat = "json_object", strictJsonSchema = false) {
+	return { openai: {
+		responseFormat: { type: responseFormat },
+		strictJsonSchema
+	} };
+}
+/** Reasoning mode for O1/O3/O4 series models. */
+function withReasoningMode(maxCompletionTokens = 25e3, reasoningEffort = "medium") {
+	return { providerOptions: { openai: {
+		maxCompletionTokens,
+		reasoningEffort
+	} } };
+}
+/** Predicted output for latency optimization. */
+function withPredictedOutput(prediction) {
+	return { openai: { prediction: {
+		type: "content",
+		content: prediction
+	} } };
+}
+/** Prompt caching control. */
+function withPromptCache(cacheEnabled = true, promptCacheKey) {
+	const options = { store: cacheEnabled };
+	if (promptCacheKey) options.promptCacheKey = promptCacheKey;
+	return { openai: options };
+}
+/** Service tier for latency/cost tradeoffs. */
+function withServiceTier(tier = "auto") {
+	return { openai: { serviceTier: tier } };
+}
+/** Strict mode for structured output validation. */
+function withStrictMode(enabled = true) {
+	return { openai: { strict: enabled } };
+}
+/** Configuration presets for OpenAI-specific use cases. */
+const OPENAI_PRESETS = {
+	FAST: {
+		...commonModes.quick(),
+		openai: { serviceTier: "flex" }
+	},
+	ACCURATE: {
+		...commonModes.precise(),
+		openai: { serviceTier: "priority" }
+	},
+	CREATIVE: {
+		...commonModes.creative(),
+		frequencyPenalty: .5,
+		presencePenalty: .5
+	},
+	REASONING: {
+		...commonModes.research(),
+		maxOutputTokens: 3e4,
+		openai: {
+			reasoningEffort: "high",
+			reasoningSummary: "auto"
+		}
+	},
+	CODING: {
+		...commonModes.code(),
+		maxOutputTokens: 8192,
+		openai: {
+			responseFormat: { type: "json_object" },
+			logprobs: true,
+			topLogprobs: 3
+		}
+	}
+};
+/** Check if model supports reasoning mode. */
+function supportsReasoningMode(modelId) {
+	return OPENAI_MODEL_GROUPS.REASONING_MODELS.includes(modelId);
+}
+/** Check if model supports service tier selection. */
+function supportsServiceTier(modelId) {
+	const isReasoning = OPENAI_MODEL_GROUPS.REASONING_MODELS.includes(modelId);
+	const supported = OPENAI_MODEL_GROUPS.CHAT_MODELS.includes(modelId) || OPENAI_MODEL_GROUPS.VISION_MODELS.includes(modelId);
+	return !isReasoning && supported;
+}
+/** Check if model supports structured outputs. */
+function supportsStructuredOutputs(modelId) {
+	return OPENAI_MODEL_GROUPS.CHAT_MODELS.includes(modelId) || OPENAI_MODEL_GROUPS.VISION_MODELS.includes(modelId);
+}
+/** Check if model supports prompt caching. */
+function supportsPromptCaching(modelId) {
+	return !OPENAI_MODEL_GROUPS.LEGACY_MODELS.includes(modelId);
+}
+/** Extract reasoning tokens from OpenAI reasoning models. */
+function extractReasoningTokens(result) {
+	const tokens = result.providerOptions?.openai?.reasoningTokens;
+	return typeof tokens === "number" ? tokens : void 0;
+}
+/** Extract cached prompt tokens from OpenAI responses. */
+function extractCachedPromptTokens(result) {
+	const tokens = result.providerOptions?.openai?.cachedPromptTokens;
+	return typeof tokens === "number" ? tokens : void 0;
+}
+/** Extract prediction tokens from OpenAI predicted outputs. */
+function extractPredictionTokens(result) {
+	const metadata = result.providerOptions?.openai;
+	if (!metadata) return void 0;
+	const accepted = metadata.acceptedPredictionTokens;
+	const rejected = metadata.rejectedPredictionTokens;
+	return {
+		accepted: typeof accepted === "number" ? accepted : void 0,
+		rejected: typeof rejected === "number" ? rejected : void 0
+	};
+}
+/** Extract complete OpenAI provider metadata. */
+function extractOpenAIMetadata(result) {
+	const openaiMeta = result.providerOptions?.openai;
+	if (!openaiMeta || typeof openaiMeta !== "object" || Array.isArray(openaiMeta)) return null;
+	const meta = openaiMeta;
+	return {
+		responseId: typeof meta.responseId === "string" ? meta.responseId : void 0,
+		reasoningTokens: typeof meta.reasoningTokens === "number" ? meta.reasoningTokens : void 0,
+		cachedPromptTokens: typeof meta.cachedPromptTokens === "number" ? meta.cachedPromptTokens : void 0,
+		acceptedPredictionTokens: typeof meta.acceptedPredictionTokens === "number" ? meta.acceptedPredictionTokens : void 0,
+		rejectedPredictionTokens: typeof meta.rejectedPredictionTokens === "number" ? meta.rejectedPredictionTokens : void 0,
+		logprobs: meta.logprobs
+	};
+}
+
+//#endregion
+//#region src/models/providers/perplexity.ts
+/**
+* @fileoverview Perplexity provider configuration
+*
+* Provider-specific model IDs, option helpers, capability detection,
+* and metadata extraction for Perplexity models.
+*
+* Note: @ai-sdk/perplexity is not a direct dependency. Perplexity is accessed
+* via createOpenAICompatible from the shared module. This file provides
+* provider-specific configurations, model IDs, and metadata extraction.
+*
+* @module @od-oneapp/ai-platform/models/providers/perplexity
+*/
+var perplexity_exports = /* @__PURE__ */ __exportAll({
+	PERPLEXITY_MODEL_GROUPS: () => PERPLEXITY_MODEL_GROUPS,
+	PERPLEXITY_MODEL_IDS: () => PERPLEXITY_MODEL_IDS,
+	extractImages: () => extractImages,
+	extractProviderMetadata: () => extractProviderMetadata,
+	extractSources: () => extractSources$1,
+	extractUsageMetadata: () => extractUsageMetadata,
+	isReasoningModel: () => isReasoningModel,
+	isResearchModel: () => isResearchModel,
+	supportsCitations: () => supportsCitations,
+	supportsImageResponses: () => supportsImageResponses,
+	supportsWebSearch: () => supportsWebSearch,
+	withImages: () => withImages,
+	withResearchMode: () => withResearchMode
+});
+/** Single source of truth for Perplexity model IDs. */
+const PERPLEXITY_MODEL_IDS = {
+	SONAR_PRO: "sonar-pro",
+	SONAR: "sonar",
+	SONAR_REASONING_PRO: "sonar-reasoning-pro",
+	SONAR_REASONING: "sonar-reasoning",
+	SONAR_DEEP_RESEARCH: "sonar-deep-research"
+};
+/** Model groups for categorization. */
+const PERPLEXITY_MODEL_GROUPS = {
+	RESEARCH_MODELS: [
+		PERPLEXITY_MODEL_IDS.SONAR_DEEP_RESEARCH,
+		PERPLEXITY_MODEL_IDS.SONAR_PRO,
+		PERPLEXITY_MODEL_IDS.SONAR
+	],
+	REASONING_MODELS: [PERPLEXITY_MODEL_IDS.SONAR_REASONING_PRO, PERPLEXITY_MODEL_IDS.SONAR_REASONING],
+	MULTIMODAL_MODELS: [
+		PERPLEXITY_MODEL_IDS.SONAR_REASONING_PRO,
+		PERPLEXITY_MODEL_IDS.SONAR_REASONING,
+		PERPLEXITY_MODEL_IDS.SONAR_PRO,
+		PERPLEXITY_MODEL_IDS.SONAR
+	]
+};
+const PERPLEXITY_MODEL_CAPABILITIES = {
+	[PERPLEXITY_MODEL_IDS.SONAR_DEEP_RESEARCH]: {
+		webSearch: true,
+		citations: true,
+		tierRequirement: "basic",
+		imageResponses: false
+	},
+	[PERPLEXITY_MODEL_IDS.SONAR_REASONING_PRO]: {
+		webSearch: true,
+		citations: true,
+		tierRequirement: "basic",
+		imageResponses: true
+	},
+	[PERPLEXITY_MODEL_IDS.SONAR_REASONING]: {
+		webSearch: true,
+		citations: true,
+		tierRequirement: "basic",
+		imageResponses: true
+	},
+	[PERPLEXITY_MODEL_IDS.SONAR_PRO]: {
+		webSearch: true,
+		citations: true,
+		tierRequirement: "basic",
+		imageResponses: true
+	},
+	[PERPLEXITY_MODEL_IDS.SONAR]: {
+		webSearch: true,
+		citations: true,
+		tierRequirement: "basic",
+		imageResponses: true
+	}
+};
+/** Enable image responses (Tier-2+ only). */
+function withImages() {
+	return { providerOptions: { perplexity: { return_images: true } } };
+}
+/** Research mode combining shared research settings with Perplexity image capability. */
+function withResearchMode(returnImages = false) {
+	return {
+		...commonModes.research(),
+		providerOptions: { perplexity: { return_images: returnImages } }
+	};
+}
+function getModelCapabilities(modelId) {
+	return PERPLEXITY_MODEL_CAPABILITIES[modelId];
+}
+/** Check if model supports image responses (Tier-2+ feature). */
+function supportsImageResponses(modelId) {
+	return getModelCapabilities(modelId)?.imageResponses ?? false;
+}
+/** Check if model supports web search. */
+function supportsWebSearch(modelId) {
+	return getModelCapabilities(modelId)?.webSearch ?? false;
+}
+/** Check if model supports citations. */
+function supportsCitations(modelId) {
+	return getModelCapabilities(modelId)?.citations ?? false;
+}
+/** Check if model has reasoning capabilities. */
+function isReasoningModel(modelId) {
+	return PERPLEXITY_MODEL_GROUPS.REASONING_MODELS.includes(modelId);
+}
+/** Check if model is optimized for research. */
+function isResearchModel(modelId) {
+	return PERPLEXITY_MODEL_GROUPS.RESEARCH_MODELS.includes(modelId);
+}
+/** Extract sources from Perplexity responses. */
+function extractSources$1(result) {
+	if (Array.isArray(result.sources)) return result.sources;
+	const perplexityMetadata = result.providerOptions?.perplexity;
+	if (!perplexityMetadata || typeof perplexityMetadata !== "object") return [];
+	const { sources } = perplexityMetadata;
+	if (!Array.isArray(sources)) return [];
+	return sources;
+}
+/** Extract image responses from Perplexity. */
+function extractImages(result) {
+	const perplexityMetadata = result.providerOptions?.perplexity;
+	if (!perplexityMetadata || typeof perplexityMetadata !== "object") return [];
+	const { images } = perplexityMetadata;
+	if (!Array.isArray(images)) return [];
+	return images;
+}
+/** Extract usage metadata from Perplexity. */
+function extractUsageMetadata(result) {
+	const perplexityMetadata = result.providerOptions?.perplexity;
+	if (!perplexityMetadata || typeof perplexityMetadata !== "object" || Array.isArray(perplexityMetadata)) return null;
+	const { usage } = perplexityMetadata;
+	if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+	const usageData = usage;
+	return {
+		citationTokens: typeof usageData.citationTokens === "number" ? usageData.citationTokens : 0,
+		numSearchQueries: typeof usageData.numSearchQueries === "number" ? usageData.numSearchQueries : 0
+	};
+}
+/** Extract complete Perplexity provider metadata. */
+function extractProviderMetadata(result) {
+	const perplexityMetadata = result.providerOptions?.perplexity;
+	if (!perplexityMetadata || typeof perplexityMetadata !== "object") return null;
+	const meta = perplexityMetadata;
+	const { usage, images } = meta;
+	const sourcesFromMetadata = meta.sources;
+	const sourcesFromResult = Array.isArray(result.sources) ? result.sources : void 0;
+	return {
+		usage: usage && typeof usage === "object" && !Array.isArray(usage) ? {
+			citationTokens: typeof usage.citationTokens === "number" ? usage.citationTokens : 0,
+			numSearchQueries: typeof usage.numSearchQueries === "number" ? usage.numSearchQueries : 0
+		} : void 0,
+		images: Array.isArray(images) ? images : [],
+		sources: sourcesFromResult && sourcesFromResult.length > 0 ? sourcesFromResult : Array.isArray(sourcesFromMetadata) ? sourcesFromMetadata : []
+	};
+}
+
+//#endregion
+//#region src/models/capabilities.ts
+/**
+* @fileoverview Cross-provider model capability detection
+*
+* Provides unified capability checks that work across all providers
+* by combining the high-level MODEL_METADATA registry with
+* provider-specific capability data.
+*
+* @module @od-oneapp/ai-platform/models/capabilities
+*/
+const REASONING_MODEL_IDS = new Set([
+	...ANTHROPIC_MODEL_GROUPS.REASONING_MODELS,
+	...OPENAI_MODEL_GROUPS.REASONING_MODELS,
+	...PERPLEXITY_MODEL_GROUPS.REASONING_MODELS
+]);
+for (const model of Object.values(Model)) {
+	const meta = MODEL_METADATA[model];
+	if (meta?.tier === "reasoning") REASONING_MODEL_IDS.add(meta.id);
+}
+/**
+* Check if a model supports reasoning/thinking capabilities.
+*
+* Checks both the registry (tier === 'reasoning') and provider-specific
+* reasoning model lists (Anthropic extended thinking, OpenAI o-series, etc.).
+*
+* @param modelId - Provider-specific model ID string (e.g. 'claude-opus-4-20250514', 'o1')
+* @returns true if the model has reasoning/thinking capabilities
+*
+* @example
+* ```ts
+* import { modelSupportsReasoning } from '@od-oneapp/ai-platform/models';
+*
+* if (modelSupportsReasoning('claude-opus-4-20250514')) {
+*   // Enable extended thinking budget
+* }
+* ```
+*/
+function modelSupportsReasoning(modelId) {
+	return REASONING_MODEL_IDS.has(modelId);
+}
+/**
+* Check if a model supports tool usage.
+*
+* @param modelId - Provider-specific model ID string
+* @returns true if the model supports tools
+*/
+function modelSupportsTools(modelId) {
+	for (const model of Object.values(Model)) {
+		const meta = MODEL_METADATA[model];
+		if (meta?.id === modelId) return meta.supportsTools;
+	}
+	return true;
+}
+/**
+* Check if a model supports streaming.
+*
+* @param modelId - Provider-specific model ID string
+* @returns true if the model supports streaming
+*/
+function modelSupportsStreaming(modelId) {
+	for (const model of Object.values(Model)) {
+		const meta = MODEL_METADATA[model];
+		if (meta?.id === modelId) return meta.supportsStreaming;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/models/providers/google.ts
+/**
+* @fileoverview Google Generative AI provider configuration
+*
+* Provider-specific model IDs, option helpers, capability detection,
+* and metadata extraction for Google Gemini models.
+*
+* All AI SDK imports come from the shared module.
+*
+* @module @od-oneapp/ai-platform/models/providers/google
+*/
+var google_exports = /* @__PURE__ */ __exportAll({
+	GOOGLE_MODEL_GROUPS: () => GOOGLE_MODEL_GROUPS,
+	GOOGLE_MODEL_IDS: () => GOOGLE_MODEL_IDS,
+	GOOGLE_PRESETS: () => GOOGLE_PRESETS,
+	GOOGLE_SAFETY_PRESETS: () => GOOGLE_SAFETY_PRESETS,
+	createGoogleGenerativeAI: () => createGoogleGenerativeAI,
+	google: () => google,
+	googleTools: () => googleTools,
+	isGemmaModel: () => isGemmaModel,
+	supportsGoogleSearch: () => supportsGoogleSearch,
+	supportsThinking: () => supportsThinking,
+	supportsUrlContext: () => supportsUrlContext,
+	withEmbeddingConfig: () => withEmbeddingConfig,
+	withGoogleImageGeneration: () => withGoogleImageGeneration,
+	withResponseModalities: () => withResponseModalities,
+	withSafetySettings: () => withSafetySettings,
+	withStructuredOutputs: () => withStructuredOutputs,
+	withThinking: () => withThinking,
+	withYouTubeContext: () => withYouTubeContext
+});
+/** Native Google tools re-exported from AI SDK. */
+const googleTools = {
+	googleSearch: google.tools.googleSearch,
+	urlContext: google.tools.urlContext,
+	codeExecution: google.tools.codeExecution
+};
+/** Single source of truth for Google model IDs. */
+const GOOGLE_MODEL_IDS = {
+	GEMINI_3_FLASH: "gemini-3-flash",
+	GEMINI_20_FLASH: "gemini-2.0-flash",
+	GEMINI_15_PRO: "gemini-1.5-pro",
+	GEMINI_15_PRO_LATEST: "gemini-1.5-pro-latest",
+	GEMINI_15_FLASH: "gemini-1.5-flash",
+	GEMINI_15_FLASH_LATEST: "gemini-1.5-flash-latest",
+	GEMINI_15_FLASH_8B: "gemini-1.5-flash-8b",
+	GEMINI_15_FLASH_8B_LATEST: "gemini-1.5-flash-8b-latest",
+	GEMMA_3_27B_IT: "gemma-3-27b-it",
+	GEMMA_3_9B_IT: "gemma-3-9b-it",
+	GEMMA_2_2B_IT: "gemma-2-2b-it",
+	GEMMA_2_9B_IT: "gemma-2-9b-it",
+	GEMMA_2_27B_IT: "gemma-2-27b-it",
+	GEMINI_EMBEDDING_001: "gemini-embedding-001",
+	TEXT_EMBEDDING_004: "text-embedding-004",
+	IMAGEN_3_GENERATE_002: "imagen-3.0-generate-002",
+	GEMMA_2_2B: "gemma-2-2b-it",
+	GEMMA_2_9B: "gemma-2-9b-it",
+	GEMMA_2_27B: "gemma-2-27b-it"
+};
+/** Model groups for categorization. */
+const GOOGLE_MODEL_GROUPS = {
+	THINKING_MODELS: [GOOGLE_MODEL_IDS.GEMINI_3_FLASH],
+	GEMINI_MODELS: [
+		GOOGLE_MODEL_IDS.GEMINI_3_FLASH,
+		GOOGLE_MODEL_IDS.GEMINI_15_PRO,
+		GOOGLE_MODEL_IDS.GEMINI_15_PRO_LATEST,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_LATEST,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_8B,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_8B_LATEST
+	],
+	MULTIMODAL_MODELS: [
+		GOOGLE_MODEL_IDS.GEMINI_3_FLASH,
+		GOOGLE_MODEL_IDS.GEMINI_15_PRO,
+		GOOGLE_MODEL_IDS.GEMINI_15_PRO_LATEST,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_LATEST,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_8B,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_8B_LATEST
+	],
+	SEARCH_CAPABLE_MODELS: [
+		GOOGLE_MODEL_IDS.GEMINI_3_FLASH,
+		GOOGLE_MODEL_IDS.GEMINI_15_PRO,
+		GOOGLE_MODEL_IDS.GEMINI_15_PRO_LATEST,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_LATEST,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_8B,
+		GOOGLE_MODEL_IDS.GEMINI_15_FLASH_8B_LATEST
+	],
+	URL_CONTEXT_MODELS: [GOOGLE_MODEL_IDS.GEMINI_3_FLASH],
+	GEMMA_MODELS: [
+		GOOGLE_MODEL_IDS.GEMMA_3_27B_IT,
+		GOOGLE_MODEL_IDS.GEMMA_3_9B_IT,
+		GOOGLE_MODEL_IDS.GEMMA_2_2B_IT,
+		GOOGLE_MODEL_IDS.GEMMA_2_9B_IT,
+		GOOGLE_MODEL_IDS.GEMMA_2_27B_IT
+	],
+	IMAGE_GENERATION_MODELS: [GOOGLE_MODEL_IDS.IMAGEN_3_GENERATE_002]
+};
+/** Configure thinking capabilities for Gemini 3.0+ models. */
+function withThinking(budgetTokens = 8192, includeThoughts = false) {
+	return { providerOptions: { google: { thinkingConfig: {
+		thinkingBudget: budgetTokens,
+		includeThoughts
+	} } } };
+}
+/** Google Safety Setting Presets. */
+const GOOGLE_SAFETY_PRESETS = {
+	STRICT: [
+		{
+			category: "HARM_CATEGORY_HATE_SPEECH",
+			threshold: "BLOCK_LOW_AND_ABOVE"
+		},
+		{
+			category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+			threshold: "BLOCK_LOW_AND_ABOVE"
+		},
+		{
+			category: "HARM_CATEGORY_HARASSMENT",
+			threshold: "BLOCK_LOW_AND_ABOVE"
+		},
+		{
+			category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+			threshold: "BLOCK_LOW_AND_ABOVE"
+		}
+	],
+	BALANCED: [
+		{
+			category: "HARM_CATEGORY_HATE_SPEECH",
+			threshold: "BLOCK_MEDIUM_AND_ABOVE"
+		},
+		{
+			category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+			threshold: "BLOCK_MEDIUM_AND_ABOVE"
+		},
+		{
+			category: "HARM_CATEGORY_HARASSMENT",
+			threshold: "BLOCK_MEDIUM_AND_ABOVE"
+		},
+		{
+			category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+			threshold: "BLOCK_MEDIUM_AND_ABOVE"
+		}
+	],
+	PERMISSIVE: [
+		{
+			category: "HARM_CATEGORY_HATE_SPEECH",
+			threshold: "BLOCK_ONLY_HIGH"
+		},
+		{
+			category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+			threshold: "BLOCK_ONLY_HIGH"
+		},
+		{
+			category: "HARM_CATEGORY_HARASSMENT",
+			threshold: "BLOCK_ONLY_HIGH"
+		},
+		{
+			category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+			threshold: "BLOCK_ONLY_HIGH"
+		}
+	],
+	NONE: [
+		{
+			category: "HARM_CATEGORY_HATE_SPEECH",
+			threshold: "BLOCK_NONE"
+		},
+		{
+			category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+			threshold: "BLOCK_NONE"
+		},
+		{
+			category: "HARM_CATEGORY_HARASSMENT",
+			threshold: "BLOCK_NONE"
+		},
+		{
+			category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+			threshold: "BLOCK_NONE"
+		}
+	]
+};
+/** Configure safety settings for content filtering. */
+function withSafetySettings(preset, overrides) {
+	let settings;
+	if (Array.isArray(preset)) settings = [...preset];
+	else {
+		settings = [...GOOGLE_SAFETY_PRESETS[preset]];
+		if (overrides) settings = settings.map((setting) => {
+			const key = setting.category.replace("HARM_CATEGORY_", "");
+			if (overrides[key]) return {
+				...setting,
+				threshold: overrides[key]
+			};
+			return setting;
+		});
+	}
+	return { providerOptions: { google: { safetySettings: settings.reduce((acc, setting) => {
+		const key = setting.category.replace("HARM_CATEGORY_", "");
+		acc[key] = setting.threshold;
+		return acc;
+	}, {}) } } };
+}
+/** Configure response modalities for multimodal outputs. */
+function withResponseModalities(modalities) {
+	return { providerOptions: { google: { responseModalities: modalities } } };
+}
+/** Configure structured outputs with schema validation. */
+function withStructuredOutputs(schema, mode = "AUTO") {
+	if (typeof schema === "boolean") return { providerOptions: { google: { structuredOutputs: {
+		enabled: schema,
+		mode
+	} } } };
+	return { providerOptions: { google: { structuredOutputs: {
+		schema,
+		mode
+	} } } };
+}
+/** Configure embedding-specific options. */
+function withEmbeddingConfig(options) {
+	return { providerOptions: { google: {
+		...options.taskType && { taskType: options.taskType },
+		...options.outputDimensionality && { outputDimensionality: options.outputDimensionality }
+	} } };
+}
+/** Configure YouTube URL processing. */
+function withYouTubeContext(videoUrl, includedFeatures) {
+	return { providerOptions: { google: { youtubeContext: {
+		videoUrl,
+		includedFeatures: includedFeatures ?? ["TRANSCRIPT"]
+	} } } };
+}
+/** Configure Google image generation options. */
+function withGoogleImageGeneration(quality = "MEDIUM", count = 1, size = 1024) {
+	return { providerOptions: { google: { imageGeneration: {
+		quality,
+		count,
+		size
+	} } } };
+}
+/** Configuration presets for Google-specific use cases. */
+const GOOGLE_PRESETS = {
+	quick: {
+		...commonModes.quick(),
+		...withSafetySettings("BALANCED"),
+		temperature: .7,
+		topP: .9
+	},
+	thinking: {
+		...commonModes.research(),
+		...withThinking(12e3, true),
+		...withSafetySettings("BALANCED"),
+		temperature: .3,
+		topP: .8
+	},
+	creative: {
+		...commonModes.creative(),
+		...withSafetySettings("PERMISSIVE"),
+		temperature: .9,
+		topP: .95
+	},
+	precise: {
+		...commonModes.precise(),
+		...withSafetySettings("STRICT"),
+		...withStructuredOutputs(true),
+		temperature: .1,
+		topP: .7
+	}
+};
+/** Check if model supports thinking capabilities. */
+function supportsThinking(modelId) {
+	return GOOGLE_MODEL_GROUPS.THINKING_MODELS.includes(modelId);
+}
+/** Check if model supports Google Search grounding. */
+function supportsGoogleSearch(modelId) {
+	return GOOGLE_MODEL_GROUPS.SEARCH_CAPABLE_MODELS.includes(modelId);
+}
+/** Check if model supports URL context analysis. */
+function supportsUrlContext(modelId) {
+	return GOOGLE_MODEL_GROUPS.URL_CONTEXT_MODELS.includes(modelId);
+}
+/** Check if model is a Gemma open-source model. */
+function isGemmaModel(modelId) {
+	return GOOGLE_MODEL_GROUPS.GEMMA_MODELS.includes(modelId);
+}
+
+//#endregion
+//#region src/models/providers/xai.ts
+/**
+* @fileoverview xAI Grok provider configuration
+*
+* Provider-specific model IDs, option helpers, capability detection,
+* and metadata extraction for xAI Grok models.
+*
+* All AI SDK imports come from the shared module.
+*
+* @module @od-oneapp/ai-platform/models/providers/xai
+*/
+var xai_exports = /* @__PURE__ */ __exportAll({
+	GROK_MODEL_GROUPS: () => GROK_MODEL_GROUPS,
+	GROK_MODEL_IDS: () => GROK_MODEL_IDS,
+	createXai: () => createXai,
+	extractSearchMetadata: () => extractSearchMetadata,
+	extractSources: () => extractSources,
+	grok: () => xai,
+	grokImage: () => grokImage,
+	supportsImageGeneration: () => supportsImageGeneration,
+	supportsLiveSearch: () => supportsLiveSearch,
+	supportsReasoningEffort: () => supportsReasoningEffort,
+	supportsVision: () => supportsVision,
+	withReasoningEffort: () => withReasoningEffort,
+	withSearchParameters: () => withSearchParameters,
+	withSearchSources: () => withSearchSources
+});
+/** Image generation support via xAI. */
+const grokImage = xai.image;
+/** Single source of truth for xAI Grok model IDs. */
+const GROK_MODEL_IDS = {
+	GROK_4: "grok-4",
+	GROK_3: "grok-3",
+	GROK_3_LATEST: "grok-3-latest",
+	GROK_3_FAST: "grok-3-fast",
+	GROK_3_FAST_LATEST: "grok-3-fast-latest",
+	GROK_3_MINI: "grok-3-mini",
+	GROK_3_MINI_LATEST: "grok-3-mini-latest",
+	GROK_3_MINI_FAST: "grok-3-mini-fast",
+	GROK_3_MINI_FAST_LATEST: "grok-3-mini-fast-latest",
+	GROK_2: "grok-2",
+	GROK_2_LATEST: "grok-2-latest",
+	GROK_2_1212: "grok-2-1212",
+	GROK_2_VISION: "grok-2-vision",
+	GROK_2_VISION_LATEST: "grok-2-vision-latest",
+	GROK_2_VISION_1212: "grok-2-vision-1212",
+	GROK_CODE_FAST_1: "grok-code-fast-1",
+	GROK_BETA: "grok-beta",
+	GROK_VISION_BETA: "grok-vision-beta",
+	GROK_2_IMAGE: "grok-2-image"
+};
+/** Model groups for categorization. */
+const GROK_MODEL_GROUPS = {
+	REASONING_EFFORT_MODELS: [
+		GROK_MODEL_IDS.GROK_3_MINI,
+		GROK_MODEL_IDS.GROK_3_MINI_LATEST,
+		GROK_MODEL_IDS.GROK_3_MINI_FAST,
+		GROK_MODEL_IDS.GROK_3_MINI_FAST_LATEST,
+		GROK_MODEL_IDS.GROK_CODE_FAST_1
+	],
+	VISION_MODELS: [
+		GROK_MODEL_IDS.GROK_2_VISION,
+		GROK_MODEL_IDS.GROK_2_VISION_LATEST,
+		GROK_MODEL_IDS.GROK_2_VISION_1212,
+		GROK_MODEL_IDS.GROK_VISION_BETA
+	]
+};
+const GROK_MODEL_CAPABILITIES = {
+	[GROK_MODEL_IDS.GROK_4]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_3]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_3_LATEST]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_3_FAST]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_3_FAST_LATEST]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_2]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_2_LATEST]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_2_1212]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_2_VISION]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_2_VISION_LATEST]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_2_VISION_1212]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_BETA]: {
+		liveSearch: true,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_3_MINI]: {
+		liveSearch: true,
+		reasoningEffort: true
+	},
+	[GROK_MODEL_IDS.GROK_3_MINI_LATEST]: {
+		liveSearch: true,
+		reasoningEffort: true
+	},
+	[GROK_MODEL_IDS.GROK_3_MINI_FAST]: {
+		liveSearch: true,
+		reasoningEffort: true
+	},
+	[GROK_MODEL_IDS.GROK_3_MINI_FAST_LATEST]: {
+		liveSearch: true,
+		reasoningEffort: true
+	},
+	[GROK_MODEL_IDS.GROK_CODE_FAST_1]: {
+		liveSearch: true,
+		reasoningEffort: true
+	},
+	[GROK_MODEL_IDS.GROK_VISION_BETA]: {
+		liveSearch: false,
+		reasoningEffort: false
+	},
+	[GROK_MODEL_IDS.GROK_2_IMAGE]: {
+		liveSearch: false,
+		reasoningEffort: false
+	}
+};
+/** Configure xAI Live Search parameters. */
+function withSearchParameters(options = {}) {
+	return { xai: { searchParameters: {
+		mode: options.mode ?? "auto",
+		returnCitations: options.returnCitations ?? true,
+		fromDate: options.fromDate,
+		toDate: options.toDate,
+		maxSearchResults: options.maxSearchResults ?? 20,
+		sources: options.sources ?? ["web", "x"]
+	} } };
+}
+/** Convenience helper for multi-source search. */
+function withSearchSources(...sources) {
+	return withSearchParameters({
+		mode: "on",
+		returnCitations: true,
+		sources
+	});
+}
+/** Configure reasoning effort for mini models. */
+function withReasoningEffort(effort) {
+	return { xai: { reasoningEffort: effort } };
+}
+/** Check if model supports Live Search. */
+function supportsLiveSearch(modelId) {
+	return GROK_MODEL_CAPABILITIES[modelId]?.liveSearch ?? false;
+}
+/** Check if model supports reasoning effort control. */
+function supportsReasoningEffort(modelId) {
+	return GROK_MODEL_CAPABILITIES[modelId]?.reasoningEffort ?? false;
+}
+/** Check if model supports vision input. */
+function supportsVision(modelId) {
+	return GROK_MODEL_GROUPS.VISION_MODELS.includes(modelId);
+}
+/** Check if model supports image generation. */
+function supportsImageGeneration(modelId) {
+	return modelId === GROK_MODEL_IDS.GROK_2_IMAGE;
+}
+/** Extract search sources from xAI responses. */
+function extractSources(result) {
+	if (!result?.sources) return [];
+	return result.sources.map((source) => ({
+		url: source.url ?? "",
+		title: source.title,
+		snippet: source.snippet,
+		sourceType: "url"
+	}));
+}
+/** Extract search metadata from xAI responses. */
+function extractSearchMetadata(result) {
+	const xaiMeta = result?.providerOptions?.xai;
+	if (!xaiMeta || typeof xaiMeta !== "object" || Array.isArray(xaiMeta)) return null;
+	const { search } = xaiMeta;
+	if (!search || typeof search !== "object" || Array.isArray(search)) return null;
+	const searchData = search;
+	return {
+		queriesUsed: typeof searchData.queriesUsed === "number" ? searchData.queriesUsed : 0,
+		sourcesFound: typeof searchData.sourcesFound === "number" ? searchData.sourcesFound : 0,
+		searchTime: typeof searchData.searchTime === "number" ? searchData.searchTime : 0
+	};
+}
+
+//#endregion
+export { getModelsByTier as _, modelSupportsTools as a, anthropic_exports as c, TOP_P as d, commonModes as f, getModelTier as g, getCheapestModel as h, modelSupportsStreaming as i, TEMPS as l, estimateCost as m, google_exports as n, perplexity_exports as o, createLanguageModel as p, modelSupportsReasoning as r, openai_exports as s, xai_exports as t, TOKENS as u };
+//# sourceMappingURL=xai-CbV_dCnP.mjs.map