@happyvertical/ai 0.74.8

package/dist/chunks/bedrock-Cf1xUerN.js

@@ -0,0 +1,808 @@
+import { A as AIError, c as extractTextContent, b as AuthenticationError, R as RateLimitError, M as ModelNotFoundError, a as ContextLengthError } from "./index-BT4thAvS.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 = {
+      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
+        });
+      }).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
+        });
+      } 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();
+    try {
+      await this.ensureClient();
+      const modelId = options.model || this.options.defaultModel;
+      const response = this.mapConverseResponse(
+        await this.client.converse(
+          await this.buildConverseRequest(messages, options, modelId)
+        ),
+        modelId
+      );
+      emitUsage(
+        this.options,
+        "bedrock",
+        "chat",
+        response.model || modelId || "unknown",
+        response.usage,
+        startTime,
+        options.usageTags
+      );
+      return response;
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  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,
+      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,
+      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);
+    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
+      }
+    );
+    return response.content;
+  }
+  async generateImage(prompt, options = {}) {
+    try {
+      await this.ensureClient();
+      const model = options.model || BEDROCK_IMAGE_GENERATION_MODEL;
+      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)
+            }
+          },
+          imageGenerationConfig: {
+            numberOfImages: options.n || 1,
+            quality: this.mapImageQuality(options.quality),
+            ...size
+          }
+        })
+      });
+      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) {
+      throw this.mapError(error);
+    }
+  }
+  async *stream(messages, options = {}) {
+    const startTime = Date.now();
+    try {
+      await this.ensureClient();
+      const modelId = options.model || this.options.defaultModel;
+      const response = await this.client.converseStream(
+        await this.buildConverseRequest(messages, options, modelId)
+      );
+      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) {
+      throw this.mapError(error);
+    }
+  }
+  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) {
+    const { system, bedrockMessages } = await this.mapMessagesToBedrock(messages);
+    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 || 4096,
+        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 }] }
+    };
+    const toolConfig = this.mapToolConfig(options);
+    if (toolConfig) {
+      request.toolConfig = toolConfig;
+    }
+    return request;
+  }
+  async mapMessagesToBedrock(messages) {
+    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);
+          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) {
+    const { bytes, mimeType } = await this.imageToBytes(imageUrl);
+    return {
+      format: this.mimeTypeToBedrockImageFormat(mimeType),
+      source: { bytes }
+    };
+  }
+  async imageToDataUrl(image) {
+    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);
+    return `data:${mimeType};base64,${Buffer.from(bytes).toString("base64")}`;
+  }
+  async imageToBase64(image) {
+    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);
+    return Buffer.from(bytes).toString("base64");
+  }
+  async imageToBytes(image) {
+    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);
+    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-Cf1xUerN.js.map