@happyvertical/ai 0.80.0 → 0.80.1

package/dist/chunks/bedrock-DDiYFUw0.js

@@ -0,0 +1,699 @@
+import { a as ContextLengthError, c as extractTextContent, o as ModelNotFoundError, r as AuthenticationError, s as RateLimitError, t as AIError } from "./types-FHs-KbGL.js";
+import { a as normalizeBaseAIOptions, c as prepareRequestControls, o as normalizeChatOptions, s as normalizeImageGenerationOptions } from "./safety-CEnoJS6X.js";
+import { t as emitUsage } from "./usage-C1Y1Nlg4.js";
+//#region src/shared/providers/bedrock.ts
+/**
+* AWS Bedrock provider implementation
+*/
+var BEDROCK_DEFAULT_CHAT_MODEL = "anthropic.claude-3-5-sonnet-20241022-v2:0";
+var BEDROCK_TEXT_EMBEDDING_MODEL = "amazon.titan-embed-text-v2:0";
+var BEDROCK_IMAGE_EMBEDDING_MODEL = "amazon.titan-embed-image-v1";
+var BEDROCK_IMAGE_GENERATION_MODEL = "amazon.titan-image-generator-v2:0";
+var BedrockProvider = class {
+	options;
+	client;
+	constructor(options) {
+		this.options = normalizeBaseAIOptions({
+			defaultModel: BEDROCK_DEFAULT_CHAT_MODEL,
+			...options
+		});
+		this.initializeClientSync();
+	}
+	initializeClientSync() {
+		try {
+			import("@aws-sdk/client-bedrock-runtime").then(({ BedrockRuntimeClient }) => {
+				this.client = new BedrockRuntimeClient({
+					region: this.options.region,
+					credentials: this.options.credentials,
+					endpoint: this.options.endpoint,
+					maxAttempts: (this.options.maxRetries || 0) + 1
+				});
+			}).catch(() => {});
+		} catch (_error) {}
+	}
+	async ensureClient() {
+		if (!this.client) try {
+			const { BedrockRuntimeClient } = await import("@aws-sdk/client-bedrock-runtime");
+			this.client = new BedrockRuntimeClient({
+				region: this.options.region,
+				credentials: this.options.credentials,
+				endpoint: this.options.endpoint,
+				maxAttempts: (this.options.maxRetries || 0) + 1
+			});
+		} catch (_error) {
+			throw new AIError("Failed to initialize Bedrock client. Make sure @aws-sdk/client-bedrock-runtime is installed.", "INITIALIZATION_ERROR", "bedrock");
+		}
+	}
+	async chat(messages, options = {}) {
+		const startTime = Date.now();
+		let controls;
+		try {
+			await this.ensureClient();
+			const modelId = options.model || this.options.defaultModel;
+			options = normalizeChatOptions(this.options, options, "bedrock", modelId);
+			controls = prepareRequestControls(this.options, options);
+			const response = this.mapConverseResponse(await this.client.converse(await this.buildConverseRequest(messages, options, modelId, controls.signal), { abortSignal: controls.signal }), modelId);
+			emitUsage(this.options, "bedrock", "chat", response.model || modelId || "unknown", response.usage, startTime, options.usageTags);
+			return response;
+		} catch (error) {
+			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "bedrock", options.model);
+			if (options.signal?.aborted) throw new AIError("AI request aborted by caller", "AI_ABORTED", "bedrock", options.model);
+			throw this.mapError(error);
+		} finally {
+			controls?.cleanup();
+		}
+	}
+	async complete(prompt, options = {}) {
+		return this.chat([{
+			role: "user",
+			content: prompt
+		}], {
+			model: options.model,
+			maxTokens: options.maxTokens,
+			temperature: options.temperature,
+			topP: options.topP,
+			n: options.n,
+			stop: options.stop,
+			stream: options.stream,
+			onProgress: options.onProgress,
+			signal: options.signal,
+			timeout: options.timeout,
+			reasoning: options.reasoning,
+			usageTags: options.usageTags
+		});
+	}
+	/**
+	* Simple message interface for single-turn interactions with optional history
+	*
+	* @param text - The message text to send
+	* @param options - Configuration options including history, model, etc.
+	* @returns Promise resolving to the response content string
+	*/
+	async message(text, options = {}) {
+		const messages = [...options.history || [], {
+			role: options.role || "user",
+			content: text
+		}];
+		return (await this.chat(messages, {
+			model: options.model,
+			maxTokens: options.maxTokens,
+			temperature: options.temperature,
+			topP: options.topP,
+			stop: options.stop,
+			stream: options.stream,
+			frequencyPenalty: options.frequencyPenalty,
+			presencePenalty: options.presencePenalty,
+			responseFormat: options.responseFormat,
+			seed: options.seed,
+			tools: options.tools,
+			toolChoice: options.toolChoice,
+			onProgress: options.onProgress,
+			signal: options.signal,
+			timeout: options.timeout,
+			reasoning: options.reasoning,
+			usageTags: options.usageTags
+		})).content;
+	}
+	async embed(text, options = {}) {
+		const startTime = Date.now();
+		try {
+			await this.ensureClient();
+			const model = options.model || BEDROCK_TEXT_EMBEDDING_MODEL;
+			const inputs = Array.isArray(text) ? text : [text];
+			const embeddings = [];
+			let totalTokens = 0;
+			for (const inputText of inputs) {
+				const response = await this.client.invokeModel({
+					modelId: model,
+					contentType: "application/json",
+					accept: "application/json",
+					body: JSON.stringify({
+						inputText,
+						...options.dimensions && { dimensions: options.dimensions },
+						normalize: true
+					})
+				});
+				const payload = await this.parseInvokeModelBody(response.body);
+				const embedding = this.extractEmbeddingVector(payload);
+				if (embedding) embeddings.push(embedding);
+				totalTokens += payload.inputTextTokenCount || payload.inputTokenCount || payload.tokenCount || 0;
+			}
+			const usage = totalTokens > 0 ? {
+				promptTokens: totalTokens,
+				completionTokens: 0,
+				totalTokens
+			} : void 0;
+			emitUsage(this.options, "bedrock", "embed", model, usage, startTime, options.usageTags);
+			return {
+				embeddings,
+				model,
+				usage
+			};
+		} catch (error) {
+			throw this.mapError(error);
+		}
+	}
+	async embedImage(image, options = {}) {
+		const startTime = Date.now();
+		try {
+			await this.ensureClient();
+			const model = options.model || BEDROCK_IMAGE_EMBEDDING_MODEL;
+			const response = await this.client.invokeModel({
+				modelId: model,
+				contentType: "application/json",
+				accept: "application/json",
+				body: JSON.stringify({
+					inputImage: await this.imageToBase64(image),
+					...options.dimensions && { embeddingConfig: { outputEmbeddingLength: options.dimensions } }
+				})
+			});
+			const payload = await this.parseInvokeModelBody(response.body);
+			const embedding = this.extractEmbeddingVector(payload);
+			emitUsage(this.options, "bedrock", "embedImage", model, void 0, startTime);
+			return {
+				embeddings: embedding ? [embedding] : [],
+				model
+			};
+		} catch (error) {
+			throw this.mapError(error);
+		}
+	}
+	async describeImage(image, prompt, options = {}) {
+		const imageUrl = await this.imageToDataUrl(image, options.signal);
+		return (await this.chat([{
+			role: "user",
+			content: [{
+				type: "text",
+				text: prompt || "Describe this image for a search index. Include objects, mood, lighting, and any visible text."
+			}, {
+				type: "image_url",
+				image_url: { url: imageUrl }
+			}]
+		}], {
+			model: options.model || this.options.defaultModel,
+			maxTokens: options.maxTokens ?? 500,
+			signal: options.signal,
+			timeout: options.timeout,
+			reasoning: options.reasoning,
+			usageTags: options.usageTags
+		})).content;
+	}
+	async generateImage(prompt, options = {}) {
+		let controls;
+		try {
+			await this.ensureClient();
+			const model = options.model || BEDROCK_IMAGE_GENERATION_MODEL;
+			options = normalizeImageGenerationOptions(this.options, options, "bedrock", model);
+			controls = prepareRequestControls(this.options, options);
+			const size = this.resolveImageSize(options);
+			const response = await this.client.invokeModel({
+				modelId: model,
+				contentType: "application/json",
+				accept: "application/json",
+				body: JSON.stringify({
+					taskType: "TEXT_IMAGE",
+					textToImageParams: {
+						text: prompt,
+						...options.imageInput && { conditionImage: await this.imageToBase64(options.imageInput, controls.signal) }
+					},
+					imageGenerationConfig: {
+						numberOfImages: options.n,
+						quality: this.mapImageQuality(options.quality),
+						...size
+					}
+				})
+			}, { abortSignal: controls.signal });
+			const payload = await this.parseInvokeModelBody(response.body);
+			if (payload.error) throw new AIError(payload.error, "API_ERROR", "bedrock");
+			return {
+				images: (payload.images || []).map((encoded) => {
+					const mimeType = "image/png";
+					if (options.outputFormat === "base64") return {
+						data: encoded,
+						mimeType
+					};
+					if (options.outputFormat === "url") return {
+						data: `data:${mimeType};base64,${encoded}`,
+						mimeType
+					};
+					return {
+						data: Buffer.from(encoded, "base64"),
+						mimeType
+					};
+				}),
+				model
+			};
+		} catch (error) {
+			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "bedrock", options.model);
+			if (options.signal?.aborted) throw new AIError("AI request aborted by caller", "AI_ABORTED", "bedrock", options.model);
+			throw this.mapError(error);
+		} finally {
+			controls?.cleanup();
+		}
+	}
+	async *stream(messages, options = {}) {
+		const startTime = Date.now();
+		let controls;
+		try {
+			await this.ensureClient();
+			const modelId = options.model || this.options.defaultModel;
+			options = normalizeChatOptions(this.options, options, "bedrock", modelId);
+			controls = prepareRequestControls(this.options, options);
+			const response = await this.client.converseStream(await this.buildConverseRequest(messages, options, modelId, controls.signal), { abortSignal: controls.signal });
+			let usage;
+			for await (const event of response.stream || []) {
+				const text = event.contentBlockDelta?.delta?.text;
+				if (text) {
+					if (options.onProgress) options.onProgress(text);
+					yield text;
+				}
+				if (event.metadata?.usage) usage = {
+					promptTokens: event.metadata.usage.inputTokens || 0,
+					completionTokens: event.metadata.usage.outputTokens || 0,
+					totalTokens: event.metadata.usage.totalTokens || 0
+				};
+			}
+			emitUsage(this.options, "bedrock", "stream", modelId || "unknown", usage, startTime, options.usageTags);
+		} catch (error) {
+			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "bedrock", options.model);
+			if (options.signal?.aborted) throw new AIError("AI request aborted by caller", "AI_ABORTED", "bedrock", options.model);
+			throw this.mapError(error);
+		} finally {
+			controls?.cleanup();
+		}
+	}
+	async countTokens(text) {
+		try {
+			await this.ensureClient();
+			const modelId = this.options.defaultModel || BEDROCK_DEFAULT_CHAT_MODEL;
+			return (await this.client.countTokens({
+				modelId,
+				input: { converse: { messages: [{
+					role: "user",
+					content: [{ text }]
+				}] } }
+			})).inputTokens || Math.ceil(text.length / 4);
+		} catch (error) {
+			throw this.mapError(error);
+		}
+	}
+	async getModels() {
+		return [
+			{
+				id: "anthropic.claude-3-5-sonnet-20241022-v2:0",
+				name: "Claude 3.5 Sonnet v2",
+				description: "Latest Claude 3.5 Sonnet model on Bedrock",
+				contextLength: 2e5,
+				capabilities: [
+					"text",
+					"chat",
+					"vision",
+					"functions"
+				],
+				supportsFunctions: true,
+				supportsVision: true
+			},
+			{
+				id: "anthropic.claude-3-opus-20240229-v1:0",
+				name: "Claude 3 Opus",
+				description: "Most powerful Claude model on Bedrock",
+				contextLength: 2e5,
+				capabilities: [
+					"text",
+					"chat",
+					"vision"
+				],
+				supportsFunctions: false,
+				supportsVision: true
+			},
+			{
+				id: "amazon.titan-text-premier-v1:0",
+				name: "Titan Text Premier",
+				description: "Premier Amazon Titan text model",
+				contextLength: 32e3,
+				capabilities: ["text", "chat"],
+				supportsFunctions: false,
+				supportsVision: false
+			},
+			{
+				id: "amazon.titan-embed-text-v1",
+				name: "Titan Embeddings Text",
+				description: "Amazon Titan text embeddings model",
+				contextLength: 8192,
+				capabilities: ["embeddings"],
+				supportsFunctions: false,
+				supportsVision: false
+			},
+			{
+				id: BEDROCK_TEXT_EMBEDDING_MODEL,
+				name: "Titan Embeddings Text V2",
+				description: "Amazon Titan text embeddings v2 model",
+				contextLength: 8192,
+				capabilities: ["embeddings"],
+				supportsFunctions: false,
+				supportsVision: false
+			},
+			{
+				id: BEDROCK_IMAGE_EMBEDDING_MODEL,
+				name: "Titan Multimodal Embeddings G1",
+				description: "Amazon Titan multimodal embeddings model for image similarity",
+				contextLength: 256,
+				capabilities: ["embeddings", "image_embedding"],
+				supportsFunctions: false,
+				supportsVision: false
+			},
+			{
+				id: BEDROCK_IMAGE_GENERATION_MODEL,
+				name: "Titan Image Generator V2",
+				description: "Amazon Titan image generation model",
+				contextLength: 0,
+				capabilities: ["image_generation"],
+				supportsFunctions: false,
+				supportsVision: false
+			},
+			{
+				id: "cohere.command-r-plus-v1:0",
+				name: "Command R+",
+				description: "Cohere Command R+ model with advanced capabilities",
+				contextLength: 128e3,
+				capabilities: [
+					"text",
+					"chat",
+					"functions"
+				],
+				supportsFunctions: true,
+				supportsVision: false
+			},
+			{
+				id: "meta.llama3-1-405b-instruct-v1:0",
+				name: "Llama 3.1 405B Instruct",
+				description: "Meta Llama 3.1 405B instruction-tuned model",
+				contextLength: 128e3,
+				capabilities: ["text", "chat"],
+				supportsFunctions: false,
+				supportsVision: false
+			}
+		];
+	}
+	async getCapabilities() {
+		return {
+			chat: true,
+			completion: true,
+			embeddings: true,
+			streaming: true,
+			functions: true,
+			vision: true,
+			fineTuning: true,
+			imageEmbeddings: true,
+			imageGeneration: true,
+			tts: false,
+			voiceCloning: false,
+			voiceDesign: false,
+			maxContextLength: 2e5,
+			supportedOperations: [
+				"chat",
+				"completion",
+				"embedding",
+				"streaming",
+				"functions",
+				"vision",
+				"image_embedding",
+				"image_generation"
+			]
+		};
+	}
+	async synthesizeSpeech(_text, _options) {
+		throw new AIError("TTS is not supported by Bedrock provider. Use Qwen3-TTS provider.", "NOT_IMPLEMENTED", "bedrock");
+	}
+	streamSpeech(_text, _options) {
+		const error = new AIError("TTS streaming is not supported by Bedrock provider. Use Qwen3-TTS provider.", "NOT_IMPLEMENTED", "bedrock");
+		return { [Symbol.asyncIterator]: () => ({ next: () => Promise.reject(error) }) };
+	}
+	async cloneVoice(_options) {
+		throw new AIError("Voice cloning is not supported by Bedrock provider. Use Qwen3-TTS provider.", "NOT_IMPLEMENTED", "bedrock");
+	}
+	async designVoice(_options) {
+		throw new AIError("Voice design is not supported by Bedrock provider. Use Qwen3-TTS provider.", "NOT_IMPLEMENTED", "bedrock");
+	}
+	async getVoices(_options) {
+		throw new AIError("Voice listing is not supported by Bedrock provider. Use Qwen3-TTS provider.", "NOT_IMPLEMENTED", "bedrock");
+	}
+	async buildConverseRequest(messages, options, modelId, signal) {
+		const { system, bedrockMessages } = await this.mapMessagesToBedrock(messages, signal);
+		const systemPrompt = options.responseFormat?.type === "json_object" ? [system, "Respond with valid JSON only. Do not include explanatory text outside the JSON object."].filter(Boolean).join("\n\n") : system;
+		const inferenceConfig = Object.fromEntries(Object.entries({
+			maxTokens: options.maxTokens,
+			temperature: options.temperature,
+			topP: options.topP,
+			stopSequences: Array.isArray(options.stop) ? options.stop : options.stop ? [options.stop] : void 0
+		}).filter(([, value]) => value !== void 0));
+		const request = {
+			modelId,
+			messages: bedrockMessages,
+			...Object.keys(inferenceConfig).length > 0 && { inferenceConfig },
+			...systemPrompt && { system: [{ text: systemPrompt }] }
+		};
+		if ((options.reasoning?.maxTokens || 0) > 0) request.additionalModelRequestFields = { thinking: {
+			type: "enabled",
+			budget_tokens: options.reasoning?.maxTokens
+		} };
+		const toolConfig = this.mapToolConfig(options);
+		if (toolConfig) request.toolConfig = toolConfig;
+		return request;
+	}
+	async mapMessagesToBedrock(messages, signal) {
+		let system;
+		const bedrockMessages = [];
+		for (const message of messages) {
+			const textContent = extractTextContent(message.content);
+			if (message.role === "system") {
+				system = system ? `${system}\n\n${textContent}` : textContent;
+				continue;
+			}
+			const content = [];
+			if (typeof message.content === "string") content.push({ text: message.content });
+			else for (const part of message.content) {
+				if (part.type === "text") {
+					content.push({ text: part.text });
+					continue;
+				}
+				const image = await this.imageUrlToBedrockImage(part.image_url.url, signal);
+				content.push({ image });
+			}
+			if (message.role === "assistant" && message.tool_calls) for (const toolCall of message.tool_calls) content.push({ toolUse: {
+				toolUseId: toolCall.id,
+				name: toolCall.function.name,
+				input: this.safeJsonParse(toolCall.function.arguments)
+			} });
+			if (content.length === 0 && textContent) content.push({ text: textContent });
+			bedrockMessages.push({
+				role: message.role === "assistant" ? "assistant" : "user",
+				content
+			});
+		}
+		return {
+			system,
+			bedrockMessages
+		};
+	}
+	mapConverseResponse(response, modelId) {
+		const contentBlocks = response.output?.message?.content || [];
+		const textContent = contentBlocks.filter((block) => typeof block.text === "string").map((block) => block.text).join("");
+		const toolCalls = contentBlocks.filter((block) => block.toolUse).map((block) => ({
+			id: block.toolUse.toolUseId,
+			type: "function",
+			function: {
+				name: block.toolUse.name,
+				arguments: JSON.stringify(block.toolUse.input || {})
+			}
+		}));
+		const usage = response.usage && {
+			promptTokens: response.usage.inputTokens || 0,
+			completionTokens: response.usage.outputTokens || 0,
+			totalTokens: response.usage.totalTokens || 0
+		};
+		return {
+			content: textContent,
+			model: modelId,
+			finishReason: this.mapBedrockFinishReason(response.stopReason),
+			usage,
+			toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+		};
+	}
+	mapBedrockFinishReason(reason) {
+		switch (reason) {
+			case "end_turn": return "stop";
+			case "max_tokens": return "length";
+			case "stop_sequence": return "stop";
+			case "tool_use": return "tool_calls";
+			default: return "stop";
+		}
+	}
+	mapToolConfig(options) {
+		if (!options.tools || options.tools.length === 0) return;
+		if (options.toolChoice === "none") return;
+		return {
+			tools: options.tools.map((tool) => ({ toolSpec: {
+				name: tool.function.name,
+				description: tool.function.description || "",
+				inputSchema: { json: tool.function.parameters || { type: "object" } }
+			} })),
+			...options.toolChoice && { toolChoice: this.mapToolChoice(options.toolChoice) }
+		};
+	}
+	mapToolChoice(toolChoice) {
+		if (!toolChoice || toolChoice === "auto") return { auto: {} };
+		if (toolChoice === "none") return;
+		return { tool: { name: toolChoice.function.name } };
+	}
+	async parseInvokeModelBody(body) {
+		const bytes = typeof body?.transformToByteArray === "function" ? await body.transformToByteArray() : body instanceof Uint8Array ? body : Buffer.isBuffer(body) ? body : new Uint8Array(body);
+		return JSON.parse(new TextDecoder().decode(bytes));
+	}
+	extractEmbeddingVector(payload) {
+		if (Array.isArray(payload.embedding)) return payload.embedding;
+		if (Array.isArray(payload.embeddings?.[0])) return payload.embeddings[0];
+		if (Array.isArray(payload.embeddingsByType?.float)) return payload.embeddingsByType.float;
+		if (Array.isArray(payload.vector)) return payload.vector;
+	}
+	async imageUrlToBedrockImage(imageUrl, signal) {
+		const { bytes, mimeType } = await this.imageToBytes(imageUrl, signal);
+		return {
+			format: this.mimeTypeToBedrockImageFormat(mimeType),
+			source: { bytes }
+		};
+	}
+	async imageToDataUrl(image, signal) {
+		if (Buffer.isBuffer(image)) return `data:image/png;base64,${image.toString("base64")}`;
+		if (image.startsWith("data:")) return image;
+		const { bytes, mimeType } = await this.imageToBytes(image, signal);
+		return `data:${mimeType};base64,${Buffer.from(bytes).toString("base64")}`;
+	}
+	async imageToBase64(image, signal) {
+		if (Buffer.isBuffer(image)) return image.toString("base64");
+		if (image.startsWith("data:")) {
+			const match = image.match(/^data:([^;]+);base64,(.+)$/);
+			if (!match) throw new AIError("Invalid base64 data URL format", "INVALID_INPUT", "bedrock");
+			return match[2];
+		}
+		const { bytes } = await this.imageToBytes(image, signal);
+		return Buffer.from(bytes).toString("base64");
+	}
+	async imageToBytes(image, signal) {
+		if (image.startsWith("data:")) {
+			const match = image.match(/^data:([^;]+);base64,(.+)$/);
+			if (!match) throw new AIError("Invalid base64 data URL format", "INVALID_INPUT", "bedrock");
+			return {
+				bytes: Uint8Array.from(Buffer.from(match[2], "base64")),
+				mimeType: match[1]
+			};
+		}
+		const response = await fetch(image, { signal });
+		if (!response.ok) throw new AIError(`Failed to fetch image: ${response.status} ${response.statusText}`, "IMAGE_FETCH_ERROR", "bedrock");
+		const arrayBuffer = await response.arrayBuffer();
+		return {
+			bytes: new Uint8Array(arrayBuffer),
+			mimeType: response.headers.get("content-type") || "image/png"
+		};
+	}
+	mimeTypeToBedrockImageFormat(mimeType) {
+		if (mimeType.includes("png")) return "png";
+		if (mimeType.includes("jpeg") || mimeType.includes("jpg")) return "jpeg";
+		if (mimeType.includes("gif")) return "gif";
+		if (mimeType.includes("webp")) return "webp";
+		throw new AIError(`Unsupported image format for Bedrock: ${mimeType}`, "INVALID_INPUT", "bedrock");
+	}
+	resolveImageSize(options) {
+		if (options.size) {
+			const [width, height] = options.size.split("x").map(Number);
+			if (Number.isFinite(width) && Number.isFinite(height)) return {
+				width,
+				height
+			};
+		}
+		return {
+			"1:1": {
+				width: 1024,
+				height: 1024
+			},
+			"2:3": {
+				width: 768,
+				height: 1152
+			},
+			"3:2": {
+				width: 1152,
+				height: 768
+			},
+			"3:5": {
+				width: 768,
+				height: 1280
+			},
+			"5:3": {
+				width: 1280,
+				height: 768
+			},
+			"7:9": {
+				width: 896,
+				height: 1152
+			},
+			"9:7": {
+				width: 1152,
+				height: 896
+			},
+			"6:11": {
+				width: 768,
+				height: 1408
+			},
+			"11:6": {
+				width: 1408,
+				height: 768
+			},
+			"5:11": {
+				width: 640,
+				height: 1408
+			},
+			"11:5": {
+				width: 1408,
+				height: 640
+			},
+			"9:5": {
+				width: 1152,
+				height: 640
+			},
+			"16:9": {
+				width: 1173,
+				height: 640
+			}
+		}[options.aspectRatio || ""] || {
+			width: 1024,
+			height: 1024
+		};
+	}
+	mapImageQuality(quality) {
+		if (!quality || quality === "standard") return "standard";
+		if (quality === "hd") return "premium";
+		return quality;
+	}
+	safeJsonParse(input) {
+		try {
+			return JSON.parse(input);
+		} catch {
+			return { rawArguments: input };
+		}
+	}
+	mapError(error) {
+		if (error instanceof AIError) return error;
+		if (typeof error === "object" && error !== null) {
+			const awsError = error;
+			if (awsError.name === "AccessDeniedException") return new AuthenticationError("bedrock");
+			if (awsError.name === "ThrottlingException") return new RateLimitError("bedrock");
+			if (awsError.name === "ResourceNotFoundException") return new ModelNotFoundError(awsError.message || "Model not found", "bedrock");
+			if (awsError.name === "ValidationException" && awsError.message?.includes("input is too long")) return new ContextLengthError("bedrock");
+		}
+		return new AIError(error instanceof Error ? error.message : "Unknown Bedrock error occurred", "UNKNOWN_ERROR", "bedrock");
+	}
+};
+//#endregion
+export { BedrockProvider };
+
+//# sourceMappingURL=bedrock-DDiYFUw0.js.map