@ai-sdk/amazon-bedrock 1.1.6 → 2.0.0

package/dist/index.js

@@ -26,15 +26,106 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/bedrock-provider.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_client_bedrock_runtime3 = require("@aws-sdk/client-bedrock-runtime");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
 
 // src/bedrock-chat-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_client_bedrock_runtime = require("@aws-sdk/client-bedrock-runtime");
+var import_provider4 = require("@ai-sdk/provider");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
-// src/bedrock-prepare-tools.ts
+// src/bedrock-api-types.ts
+var BEDROCK_STOP_REASONS = [
+  "stop",
+  "stop_sequence",
+  "end_turn",
+  "length",
+  "max_tokens",
+  "content-filter",
+  "content_filtered",
+  "guardrail_intervened",
+  "tool-calls",
+  "tool_use"
+];
+
+// src/bedrock-error.ts
+var import_zod = require("zod");
+var BedrockErrorSchema = import_zod.z.object({
+  message: import_zod.z.string(),
+  type: import_zod.z.string().nullish()
+});
+
+// src/bedrock-event-stream-response-handler.ts
 var import_provider = require("@ai-sdk/provider");
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_eventstream_codec = require("@smithy/eventstream-codec");
+var import_util_utf8 = require("@smithy/util-utf8");
+var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response }) => {
+  const responseHeaders = (0, import_provider_utils.extractResponseHeaders)(response);
+  if (response.body == null) {
+    throw new import_provider.EmptyResponseBodyError({});
+  }
+  const codec = new import_eventstream_codec.EventStreamCodec(import_util_utf8.toUtf8, import_util_utf8.fromUtf8);
+  let buffer = new Uint8Array(0);
+  const textDecoder = new TextDecoder();
+  return {
+    responseHeaders,
+    value: response.body.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          var _a, _b;
+          const newBuffer = new Uint8Array(buffer.length + chunk.length);
+          newBuffer.set(buffer);
+          newBuffer.set(chunk, buffer.length);
+          buffer = newBuffer;
+          while (buffer.length >= 4) {
+            const totalLength = new DataView(
+              buffer.buffer,
+              buffer.byteOffset,
+              buffer.byteLength
+            ).getUint32(0, false);
+            if (buffer.length < totalLength) {
+              break;
+            }
+            try {
+              const subView = buffer.subarray(0, totalLength);
+              const decoded = codec.decode(subView);
+              buffer = buffer.slice(totalLength);
+              if (((_a = decoded.headers[":message-type"]) == null ? void 0 : _a.value) === "event") {
+                const data = textDecoder.decode(decoded.body);
+                const parsedDataResult = (0, import_provider_utils.safeParseJSON)({ text: data });
+                if (!parsedDataResult.success) {
+                  controller.enqueue(parsedDataResult);
+                  break;
+                }
+                delete parsedDataResult.value.p;
+                let wrappedData = {
+                  [(_b = decoded.headers[":event-type"]) == null ? void 0 : _b.value]: parsedDataResult.value
+                };
+                const validatedWrappedData = (0, import_provider_utils.safeValidateTypes)({
+                  value: wrappedData,
+                  schema: chunkSchema
+                });
+                if (!validatedWrappedData.success) {
+                  controller.enqueue(validatedWrappedData);
+                } else {
+                  controller.enqueue({
+                    success: true,
+                    value: validatedWrappedData.value,
+                    rawValue: wrappedData
+                  });
+                }
+              }
+            } catch (e) {
+              break;
+            }
+          }
+        }
+      })
+    )
+  };
+};
+
+// src/bedrock-prepare-tools.ts
+var import_provider2 = require("@ai-sdk/provider");
 function prepareTools(mode) {
   var _a;
   const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
@@ -95,7 +186,7 @@ function prepareTools(mode) {
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider.UnsupportedFunctionalityError({
+      throw new import_provider2.UnsupportedFunctionalityError({
         functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -103,9 +194,9 @@ function prepareTools(mode) {
 }
 
 // src/convert-to-bedrock-chat-messages.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var generateFileId = (0, import_provider_utils.createIdGenerator)({ prefix: "file", size: 16 });
+var import_provider3 = require("@ai-sdk/provider");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var generateFileId = (0, import_provider_utils2.createIdGenerator)({ prefix: "file", size: 16 });
 function convertToBedrockChatMessages(prompt) {
   var _a, _b, _c, _d, _e;
   const blocks = groupIntoBlocks(prompt);
@@ -118,7 +209,7 @@ function convertToBedrockChatMessages(prompt) {
     switch (type) {
       case "system": {
         if (messages.length > 0) {
-          throw new import_provider2.UnsupportedFunctionalityError({
+          throw new import_provider3.UnsupportedFunctionalityError({
             functionality: "Multiple system messages that are separated by user/assistant messages"
           });
         }
@@ -142,15 +233,19 @@ function convertToBedrockChatMessages(prompt) {
                   }
                   case "image": {
                     if (part.image instanceof URL) {
-                      throw new import_provider2.UnsupportedFunctionalityError({
+                      throw new import_provider3.UnsupportedFunctionalityError({
                         functionality: "Image URLs in user messages"
                       });
                     }
                     bedrockContent.push({
                       image: {
-                        format: (_b = (_a = part.mimeType) == null ? void 0 : _a.split("/")) == null ? void 0 : _b[1],
+                        format: (_b = (_a = part.mimeType) == null ? void 0 : _a.split(
+                          "/"
+                        )) == null ? void 0 : _b[1],
                         source: {
-                          bytes: (_c = part.image) != null ? _c : part.image
+                          bytes: (0, import_provider_utils2.convertUint8ArrayToBase64)(
+                            (_c = part.image) != null ? _c : part.image
+                          )
                         }
                       }
                     });
@@ -158,7 +253,7 @@ function convertToBedrockChatMessages(prompt) {
                   }
                   case "file": {
                     if (part.data instanceof URL) {
-                      throw new import_provider2.UnsupportedFunctionalityError({
+                      throw new import_provider3.UnsupportedFunctionalityError({
                         functionality: "File URLs in user messages"
                       });
                     }
@@ -169,7 +264,7 @@ function convertToBedrockChatMessages(prompt) {
                         )) == null ? void 0 : _e[1],
                         name: generateFileId(),
                         source: {
-                          bytes: Buffer.from(part.data, "base64")
+                          bytes: part.data
                         }
                       }
                     });
@@ -314,15 +409,16 @@ function mapBedrockFinishReason(finishReason) {
 }
 
 // src/bedrock-chat-language-model.ts
+var import_zod2 = require("zod");
 var BedrockChatLanguageModel = class {
   constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
     this.specificationVersion = "v1";
     this.provider = "amazon-bedrock";
     this.defaultObjectGenerationMode = "tool";
     this.supportsImageUrls = false;
-    this.modelId = modelId;
-    this.settings = settings;
-    this.config = config;
   }
   getArgs({
     mode,
@@ -339,7 +435,7 @@ var BedrockChatLanguageModel = class {
     providerMetadata,
     headers
   }) {
-    var _a, _b;
+    var _a;
     const type = mode.type;
     const warnings = [];
     if (frequencyPenalty != null) {
@@ -360,12 +456,6 @@ var BedrockChatLanguageModel = class {
         setting: "seed"
       });
     }
-    if (headers != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "headers"
-      });
-    }
     if (topK != null) {
       warnings.push({
         type: "unsupported-setting",
@@ -380,18 +470,20 @@ var BedrockChatLanguageModel = class {
       });
     }
     const { system, messages } = convertToBedrockChatMessages(prompt);
+    const inferenceConfig = {
+      ...maxTokens != null && { maxTokens },
+      ...temperature != null && { temperature },
+      ...topP != null && { topP },
+      ...stopSequences != null && { stopSequences }
+    };
     const baseArgs = {
-      modelId: this.modelId,
       system: system ? [{ text: system }] : void 0,
       additionalModelRequestFields: this.settings.additionalModelRequestFields,
-      inferenceConfig: {
-        maxTokens,
-        temperature,
-        topP,
-        stopSequences
+      ...Object.keys(inferenceConfig).length > 0 && {
+        inferenceConfig
       },
       messages,
-      guardrailConfig: (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.guardrailConfig
+      ...providerMetadata == null ? void 0 : providerMetadata.bedrock
     };
     switch (type) {
       case "regular": {
@@ -399,13 +491,13 @@ var BedrockChatLanguageModel = class {
         return {
           command: {
             ...baseArgs,
-            ...((_b = toolConfig.tools) == null ? void 0 : _b.length) ? { toolConfig } : {}
+            ...((_a = toolConfig.tools) == null ? void 0 : _a.length) ? { toolConfig } : {}
           },
           warnings: [...warnings, ...toolWarnings]
         };
       }
       case "object-json": {
-        throw new import_provider3.UnsupportedFunctionalityError({
+        throw new import_provider4.UnsupportedFunctionalityError({
           functionality: "json-mode object generation"
         });
       }
@@ -439,11 +531,29 @@ var BedrockChatLanguageModel = class {
   }
   async doGenerate(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-    const { command, warnings } = this.getArgs(options);
-    const response = await this.config.client.send(
-      new import_client_bedrock_runtime.ConverseCommand(command)
-    );
-    const { messages: rawPrompt, ...rawSettings } = command;
+    const { command: args, warnings } = this.getArgs(options);
+    const url = `${this.getUrl(this.modelId)}/converse`;
+    const { value: response, responseHeaders } = await (0, import_provider_utils3.postJsonToApi)({
+      url,
+      headers: (0, import_provider_utils3.combineHeaders)(
+        await (0, import_provider_utils3.resolve)(this.config.headers),
+        options.headers
+      ),
+      body: args,
+      failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)({
+        errorSchema: BedrockErrorSchema,
+        errorToMessage: (error) => {
+          var _a2;
+          return `${(_a2 = error.message) != null ? _a2 : "Unknown error"}`;
+        }
+      }),
+      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+        BedrockResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { messages: rawPrompt, ...rawSettings } = args;
     const providerMetadata = response.trace ? { bedrock: { trace: response.trace } } : void 0;
     return {
       text: (_d = (_c = (_b = (_a = response.output) == null ? void 0 : _a.message) == null ? void 0 : _b.content) == null ? void 0 : _c.map((part) => {
@@ -459,48 +569,53 @@ var BedrockChatLanguageModel = class {
           args: JSON.stringify((_f2 = (_e2 = part.toolUse) == null ? void 0 : _e2.input) != null ? _f2 : "")
         };
       }),
-      finishReason: mapBedrockFinishReason(response.stopReason),
+      finishReason: mapBedrockFinishReason(
+        response.stopReason
+      ),
       usage: {
         promptTokens: (_j = (_i = response.usage) == null ? void 0 : _i.inputTokens) != null ? _j : Number.NaN,
         completionTokens: (_l = (_k = response.usage) == null ? void 0 : _k.outputTokens) != null ? _l : Number.NaN
       },
       rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders },
       warnings,
-      providerMetadata
+      ...providerMetadata && { providerMetadata }
     };
   }
   async doStream(options) {
-    const { command, warnings } = this.getArgs(options);
-    const response = await this.config.client.send(
-      new import_client_bedrock_runtime.ConverseStreamCommand(command)
-    );
-    const { messages: rawPrompt, ...rawSettings } = command;
+    const { command: args, warnings } = this.getArgs(options);
+    const url = `${this.getUrl(this.modelId)}/converse-stream`;
+    const { value: response, responseHeaders } = await (0, import_provider_utils3.postJsonToApi)({
+      url,
+      headers: (0, import_provider_utils3.combineHeaders)(
+        await (0, import_provider_utils3.resolve)(this.config.headers),
+        options.headers
+      ),
+      body: args,
+      failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)({
+        errorSchema: BedrockErrorSchema,
+        errorToMessage: (error) => `${error.type}: ${error.message}`
+      }),
+      successfulResponseHandler: createBedrockEventStreamResponseHandler(BedrockStreamSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { messages: rawPrompt, ...rawSettings } = args;
     let finishReason = "unknown";
     let usage = {
       promptTokens: Number.NaN,
       completionTokens: Number.NaN
     };
     let providerMetadata = void 0;
-    if (!response.stream) {
-      throw new Error("No stream found");
-    }
-    const stream = new ReadableStream({
-      async start(controller) {
-        for await (const chunk of response.stream) {
-          controller.enqueue({ success: true, value: chunk });
-        }
-        controller.close();
-      }
-    });
     const toolCallContentBlocks = {};
     return {
-      stream: stream.pipeThrough(
+      stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-            function enqueueError(error) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            function enqueueError(bedrockError) {
               finishReason = "error";
-              controller.enqueue({ type: "error", error });
+              controller.enqueue({ type: "error", error: bedrockError });
             }
             if (!chunk.success) {
               enqueueError(chunk.error);
@@ -541,14 +656,14 @@ var BedrockChatLanguageModel = class {
                 };
               }
             }
-            if ((_f = (_e = value.contentBlockDelta) == null ? void 0 : _e.delta) == null ? void 0 : _f.text) {
+            if (((_e = value.contentBlockDelta) == null ? void 0 : _e.delta) && "text" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.text) {
               controller.enqueue({
                 type: "text-delta",
                 textDelta: value.contentBlockDelta.delta.text
               });
             }
             const contentBlockStart = value.contentBlockStart;
-            if (((_g = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _g.toolUse) != null) {
+            if (((_f = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _f.toolUse) != null) {
               const toolUse = contentBlockStart.start.toolUse;
               toolCallContentBlocks[contentBlockStart.contentBlockIndex] = {
                 toolCallId: toolUse.toolUseId,
@@ -557,9 +672,9 @@ var BedrockChatLanguageModel = class {
               };
             }
             const contentBlockDelta = value.contentBlockDelta;
-            if ((_h = contentBlockDelta == null ? void 0 : contentBlockDelta.delta) == null ? void 0 : _h.toolUse) {
+            if ((contentBlockDelta == null ? void 0 : contentBlockDelta.delta) && "toolUse" in contentBlockDelta.delta && contentBlockDelta.delta.toolUse) {
               const contentBlock = toolCallContentBlocks[contentBlockDelta.contentBlockIndex];
-              const delta = (_i = contentBlockDelta.delta.toolUse.input) != null ? _i : "";
+              const delta = (_g = contentBlockDelta.delta.toolUse.input) != null ? _g : "";
               controller.enqueue({
                 type: "tool-call-delta",
                 toolCallType: "function",
@@ -590,97 +705,275 @@ var BedrockChatLanguageModel = class {
               type: "finish",
               finishReason,
               usage,
-              providerMetadata
+              ...providerMetadata && { providerMetadata }
             });
           }
         })
       ),
       rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders },
       warnings
     };
   }
+  getUrl(modelId) {
+    const encodedModelId = encodeURIComponent(modelId);
+    return `${this.config.baseUrl()}/model/${encodedModelId}`;
+  }
 };
+var BedrockStopReasonSchema = import_zod2.z.union([
+  import_zod2.z.enum(BEDROCK_STOP_REASONS),
+  import_zod2.z.string()
+]);
+var BedrockToolUseSchema = import_zod2.z.object({
+  toolUseId: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  input: import_zod2.z.unknown()
+});
+var BedrockResponseSchema = import_zod2.z.object({
+  metrics: import_zod2.z.object({
+    latencyMs: import_zod2.z.number()
+  }).nullish(),
+  output: import_zod2.z.object({
+    message: import_zod2.z.object({
+      content: import_zod2.z.array(
+        import_zod2.z.object({
+          text: import_zod2.z.string().nullish(),
+          toolUse: BedrockToolUseSchema.nullish()
+        })
+      ),
+      role: import_zod2.z.string()
+    })
+  }),
+  stopReason: BedrockStopReasonSchema,
+  trace: import_zod2.z.unknown().nullish(),
+  usage: import_zod2.z.object({
+    inputTokens: import_zod2.z.number(),
+    outputTokens: import_zod2.z.number(),
+    totalTokens: import_zod2.z.number()
+  })
+});
+var BedrockStreamSchema = import_zod2.z.object({
+  contentBlockDelta: import_zod2.z.object({
+    contentBlockIndex: import_zod2.z.number(),
+    delta: import_zod2.z.union([
+      import_zod2.z.object({ text: import_zod2.z.string() }),
+      import_zod2.z.object({ toolUse: import_zod2.z.object({ input: import_zod2.z.string() }) })
+    ]).nullish()
+  }).nullish(),
+  contentBlockStart: import_zod2.z.object({
+    contentBlockIndex: import_zod2.z.number(),
+    start: import_zod2.z.object({
+      toolUse: BedrockToolUseSchema.nullish()
+    }).nullish()
+  }).nullish(),
+  contentBlockStop: import_zod2.z.object({
+    contentBlockIndex: import_zod2.z.number()
+  }).nullish(),
+  internalServerException: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
+  messageStop: import_zod2.z.object({
+    additionalModelResponseFields: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
+    stopReason: BedrockStopReasonSchema
+  }).nullish(),
+  metadata: import_zod2.z.object({
+    trace: import_zod2.z.unknown().nullish(),
+    usage: import_zod2.z.object({
+      inputTokens: import_zod2.z.number(),
+      outputTokens: import_zod2.z.number()
+    }).nullish()
+  }).nullish(),
+  modelStreamErrorException: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
+  throttlingException: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
+  validationException: import_zod2.z.record(import_zod2.z.unknown()).nullish()
+});
 
 // src/bedrock-embedding-model.ts
-var import_client_bedrock_runtime2 = require("@aws-sdk/client-bedrock-runtime");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_zod3 = require("zod");
 var BedrockEmbeddingModel = class {
   constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
     this.specificationVersion = "v1";
     this.provider = "amazon-bedrock";
     this.maxEmbeddingsPerCall = void 0;
     this.supportsParallelCalls = true;
-    this.modelId = modelId;
-    this.config = config;
-    this.settings = settings;
+  }
+  getUrl(modelId) {
+    const encodedModelId = encodeURIComponent(modelId);
+    return `${this.config.baseUrl()}/model/${encodedModelId}/invoke`;
   }
   async doEmbed({
-    values
+    values,
+    headers,
+    abortSignal
   }) {
-    const fn = async (inputText) => {
-      const payload = {
+    const embedSingleText = async (inputText) => {
+      const args = {
         inputText,
         dimensions: this.settings.dimensions,
         normalize: this.settings.normalize
       };
-      const command = new import_client_bedrock_runtime2.InvokeModelCommand({
-        contentType: "application/json",
-        body: JSON.stringify(payload),
-        modelId: this.modelId
+      const url = this.getUrl(this.modelId);
+      const { value: response } = await (0, import_provider_utils4.postJsonToApi)({
+        url,
+        headers: await (0, import_provider_utils4.resolve)(
+          (0, import_provider_utils4.combineHeaders)(await (0, import_provider_utils4.resolve)(this.config.headers), headers)
+        ),
+        body: args,
+        failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
+          errorSchema: BedrockErrorSchema,
+          errorToMessage: (error) => `${error.type}: ${error.message}`
+        }),
+        successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+          BedrockEmbeddingResponseSchema
+        ),
+        fetch: this.config.fetch,
+        abortSignal
       });
-      const rawResponse = await this.config.client.send(command);
-      const parsed = JSON.parse(new TextDecoder().decode(rawResponse.body));
-      return parsed;
+      return {
+        embedding: response.embedding,
+        inputTextTokenCount: response.inputTextTokenCount
+      };
     };
-    const responses = await Promise.all(values.map(fn));
-    const response = responses.reduce(
-      (acc, r) => {
-        acc.embeddings.push(r.embedding);
-        acc.usage.tokens += r.inputTextTokenCount;
-        return acc;
+    const responses = await Promise.all(values.map(embedSingleText));
+    return responses.reduce(
+      (accumulated, response) => {
+        accumulated.embeddings.push(response.embedding);
+        accumulated.usage.tokens += response.inputTextTokenCount;
+        return accumulated;
       },
       { embeddings: [], usage: { tokens: 0 } }
     );
-    return response;
   }
 };
+var BedrockEmbeddingResponseSchema = import_zod3.z.object({
+  embedding: import_zod3.z.array(import_zod3.z.number()),
+  inputTextTokenCount: import_zod3.z.number()
+});
+
+// src/headers-utils.ts
+function extractHeaders(headers) {
+  let originalHeaders = {};
+  if (headers) {
+    if (headers instanceof Headers) {
+      originalHeaders = convertHeadersToRecord(headers);
+    } else if (Array.isArray(headers)) {
+      for (const [k, v] of headers) {
+        originalHeaders[k.toLowerCase()] = v;
+      }
+    } else {
+      originalHeaders = Object.fromEntries(
+        Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v])
+      );
+    }
+  }
+  return originalHeaders;
+}
+function convertHeadersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key.toLowerCase()] = value;
+  });
+  return record;
+}
+
+// src/bedrock-sigv4-fetch.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_aws4fetch = require("aws4fetch");
+function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
+  return async (input, init) => {
+    var _a;
+    if (((_a = init == null ? void 0 : init.method) == null ? void 0 : _a.toUpperCase()) !== "POST" || !(init == null ? void 0 : init.body)) {
+      return fetch(input, init);
+    }
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const originalHeaders = extractHeaders(init.headers);
+    const body = prepareBodyString(init.body);
+    const credentials = getCredentials();
+    const signer = new import_aws4fetch.AwsV4Signer({
+      url,
+      method: "POST",
+      headers: Object.entries((0, import_provider_utils5.removeUndefinedEntries)(originalHeaders)),
+      body,
+      region: credentials.region,
+      accessKeyId: credentials.accessKeyId,
+      secretAccessKey: credentials.secretAccessKey,
+      sessionToken: credentials.sessionToken,
+      service: "bedrock"
+    });
+    const signingResult = await signer.sign();
+    const signedHeaders = convertHeadersToRecord(signingResult.headers);
+    return fetch(input, {
+      ...init,
+      body,
+      headers: (0, import_provider_utils5.removeUndefinedEntries)(
+        (0, import_provider_utils5.combineHeaders)(originalHeaders, signedHeaders)
+      )
+    });
+  };
+}
+function prepareBodyString(body) {
+  if (typeof body === "string") {
+    return body;
+  } else if (body instanceof Uint8Array) {
+    return new TextDecoder().decode(body);
+  } else if (body instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(body));
+  } else {
+    return JSON.stringify(body);
+  }
+}
 
 // src/bedrock-provider.ts
 function createAmazonBedrock(options = {}) {
-  const createBedrockRuntimeClient = () => {
+  const sigv4Fetch = createSigV4FetchFunction(
+    () => ({
+      region: (0, import_provider_utils6.loadSetting)({
+        settingValue: options.region,
+        settingName: "region",
+        environmentVariableName: "AWS_REGION",
+        description: "AWS region"
+      }),
+      accessKeyId: (0, import_provider_utils6.loadSetting)({
+        settingValue: options.accessKeyId,
+        settingName: "accessKeyId",
+        environmentVariableName: "AWS_ACCESS_KEY_ID",
+        description: "AWS access key ID"
+      }),
+      secretAccessKey: (0, import_provider_utils6.loadSetting)({
+        settingValue: options.secretAccessKey,
+        settingName: "secretAccessKey",
+        environmentVariableName: "AWS_SECRET_ACCESS_KEY",
+        description: "AWS secret access key"
+      }),
+      sessionToken: (0, import_provider_utils6.loadOptionalSetting)({
+        settingValue: options.sessionToken,
+        environmentVariableName: "AWS_SESSION_TOKEN"
+      })
+    }),
+    options.fetch
+  );
+  const getBaseUrl = () => {
+    var _a, _b;
+    return (_b = (0, import_provider_utils6.withoutTrailingSlash)(
+      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${(0, import_provider_utils6.loadSetting)({
+        settingValue: options.region,
+        settingName: "region",
+        environmentVariableName: "AWS_REGION",
+        description: "AWS region"
+      })}.amazonaws.com`
+    )) != null ? _b : `https://bedrock-runtime.us-east-1.amazonaws.com`;
+  };
+  const createChatModel = (modelId, settings = {}) => {
     var _a;
-    return new import_client_bedrock_runtime3.BedrockRuntimeClient(
-      (_a = options.bedrockOptions) != null ? _a : {
-        region: (0, import_provider_utils2.loadSetting)({
-          settingValue: options.region,
-          settingName: "region",
-          environmentVariableName: "AWS_REGION",
-          description: "AWS region"
-        }),
-        credentials: {
-          accessKeyId: (0, import_provider_utils2.loadSetting)({
-            settingValue: options.accessKeyId,
-            settingName: "accessKeyId",
-            environmentVariableName: "AWS_ACCESS_KEY_ID",
-            description: "AWS access key ID"
-          }),
-          secretAccessKey: (0, import_provider_utils2.loadSetting)({
-            settingValue: options.secretAccessKey,
-            settingName: "secretAccessKey",
-            environmentVariableName: "AWS_SECRET_ACCESS_KEY",
-            description: "AWS secret access key"
-          }),
-          sessionToken: (0, import_provider_utils2.loadOptionalSetting)({
-            settingValue: options.sessionToken,
-            environmentVariableName: "AWS_SESSION_TOKEN"
-          })
-        }
-      }
-    );
+    return new BedrockChatLanguageModel(modelId, settings, {
+      baseUrl: getBaseUrl,
+      headers: (_a = options.headers) != null ? _a : {},
+      fetch: sigv4Fetch,
+      generateId: import_provider_utils6.generateId
+    });
   };
-  const createChatModel = (modelId, settings = {}) => new BedrockChatLanguageModel(modelId, settings, {
-    client: createBedrockRuntimeClient(),
-    generateId: import_provider_utils2.generateId
-  });
   const provider = function(modelId, settings) {
     if (new.target) {
       throw new Error(
@@ -689,9 +982,14 @@ function createAmazonBedrock(options = {}) {
     }
     return createChatModel(modelId, settings);
   };
-  const createEmbeddingModel = (modelId, settings = {}) => new BedrockEmbeddingModel(modelId, settings, {
-    client: createBedrockRuntimeClient()
-  });
+  const createEmbeddingModel = (modelId, settings = {}) => {
+    var _a;
+    return new BedrockEmbeddingModel(modelId, settings, {
+      baseUrl: getBaseUrl,
+      headers: (_a = options.headers) != null ? _a : {},
+      fetch: sigv4Fetch
+    });
+  };
   provider.languageModel = createChatModel;
   provider.embedding = createEmbeddingModel;
   provider.textEmbedding = createEmbeddingModel;