@happyvertical/ai 0.80.0 → 0.80.2

package/dist/chunks/bedrock-Dc2eVPUD.js

@@ -1,920 +0,0 @@
-import { b as normalizeBaseAIOptions, A as AIError, n as normalizeChatOptions, p as prepareRequestControls, a as normalizeImageGenerationOptions, f as extractTextContent, d as AuthenticationError, R as RateLimitError, M as ModelNotFoundError, c as ContextLengthError } from "./index-DCXO0nZA.js";
-import { e as emitUsage } from "./usage-DMWiJ2oB.js";
-const BEDROCK_DEFAULT_CHAT_MODEL = "anthropic.claude-3-5-sonnet-20241022-v2:0";
-const BEDROCK_TEXT_EMBEDDING_MODEL = "amazon.titan-embed-text-v2:0";
-const BEDROCK_IMAGE_EMBEDDING_MODEL = "amazon.titan-embed-image-v1";
-const BEDROCK_IMAGE_GENERATION_MODEL = "amazon.titan-image-generator-v2:0";
-class BedrockProvider {
-  options;
-  client;
-  // Will be BedrockRuntimeClient instance from @aws-sdk/client-bedrock-runtime
-  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 }
-    ];
-    const response = 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
-    });
-    return response.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);
-    const response = 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
-      }
-    );
-    return response.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");
-      }
-      const 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
-        };
-      });
-      return {
-        images,
-        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;
-      const response = await this.client.countTokens({
-        modelId,
-        input: {
-          converse: {
-            messages: [
-              {
-                role: "user",
-                content: [{ text }]
-              }
-            ]
-          }
-        }
-      });
-      return response.inputTokens || Math.ceil(text.length / 4);
-    } catch (error) {
-      throw this.mapError(error);
-    }
-  }
-  async getModels() {
-    return [
-      // Anthropic Claude models
-      {
-        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
-      },
-      // Amazon Titan models
-      {
-        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
-      },
-      // Cohere models
-      {
-        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
-      },
-      // Meta Llama models
-      {
-        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,
-      // Some models support function calling
-      vision: true,
-      // Some models support vision
-      fineTuning: true,
-      // Via Bedrock fine-tuning
-      imageEmbeddings: true,
-      imageGeneration: true,
-      tts: false,
-      voiceCloning: false,
-      voiceDesign: false,
-      maxContextLength: 2e5,
-      supportedOperations: [
-        "chat",
-        "completion",
-        "embedding",
-        "streaming",
-        "functions",
-        "vision",
-        "image_embedding",
-        "image_generation"
-      ]
-    };
-  }
-  // ============================================================================
-  // TTS Methods (Not supported - use Qwen3-TTS provider)
-  // ============================================================================
-  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}
-
-${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 void 0;
-    }
-    if (options.toolChoice === "none") {
-      return void 0;
-    }
-    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 void 0;
-    }
-    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;
-    }
-    return void 0;
-  }
-  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 };
-      }
-    }
-    const aspectRatioSizes = {
-      "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 }
-    };
-    return aspectRatioSizes[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");
-      }
-    }
-    const errorMessage = error instanceof Error ? error.message : "Unknown Bedrock error occurred";
-    return new AIError(errorMessage, "UNKNOWN_ERROR", "bedrock");
-  }
-}
-export {
-  BedrockProvider
-};
-//# sourceMappingURL=bedrock-Dc2eVPUD.js.map