@ai-sdk/amazon-bedrock 1.1.5 → 2.0.0

package/dist/index.mjs

@@ -2,20 +2,117 @@
 import {
   generateId,
   loadOptionalSetting,
-  loadSetting
+  loadSetting,
+  withoutTrailingSlash
 } from "@ai-sdk/provider-utils";
-import {
-  BedrockRuntimeClient as BedrockRuntimeClient3
-} from "@aws-sdk/client-bedrock-runtime";
 
 // src/bedrock-chat-language-model.ts
 import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 import {
-  ConverseCommand,
-  ConverseStreamCommand
-} from "@aws-sdk/client-bedrock-runtime";
+  combineHeaders,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  postJsonToApi,
+  resolve
+} from "@ai-sdk/provider-utils";
+
+// 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
+import { z } from "zod";
+var BedrockErrorSchema = z.object({
+  message: z.string(),
+  type: z.string().nullish()
+});
+
+// src/bedrock-event-stream-response-handler.ts
+import { EmptyResponseBodyError } from "@ai-sdk/provider";
+import {
+  safeParseJSON,
+  extractResponseHeaders,
+  safeValidateTypes
+} from "@ai-sdk/provider-utils";
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { toUtf8, fromUtf8 } from "@smithy/util-utf8";
+var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response }) => {
+  const responseHeaders = extractResponseHeaders(response);
+  if (response.body == null) {
+    throw new EmptyResponseBodyError({});
+  }
+  const codec = new EventStreamCodec(toUtf8, 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 = 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 = 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
 import {
@@ -92,7 +189,10 @@ function prepareTools(mode) {
 import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
-import { createIdGenerator } from "@ai-sdk/provider-utils";
+import {
+  createIdGenerator,
+  convertUint8ArrayToBase64
+} from "@ai-sdk/provider-utils";
 var generateFileId = createIdGenerator({ prefix: "file", size: 16 });
 function convertToBedrockChatMessages(prompt) {
   var _a, _b, _c, _d, _e;
@@ -136,9 +236,13 @@ function convertToBedrockChatMessages(prompt) {
                     }
                     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: convertUint8ArrayToBase64(
+                            (_c = part.image) != null ? _c : part.image
+                          )
                         }
                       }
                     });
@@ -157,7 +261,7 @@ function convertToBedrockChatMessages(prompt) {
                         )) == null ? void 0 : _e[1],
                         name: generateFileId(),
                         source: {
-                          bytes: Buffer.from(part.data, "base64")
+                          bytes: part.data
                         }
                       }
                     });
@@ -302,15 +406,16 @@ function mapBedrockFinishReason(finishReason) {
 }
 
 // src/bedrock-chat-language-model.ts
+import { z as z2 } from "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,
@@ -327,7 +432,7 @@ var BedrockChatLanguageModel = class {
     providerMetadata,
     headers
   }) {
-    var _a, _b;
+    var _a;
     const type = mode.type;
     const warnings = [];
     if (frequencyPenalty != null) {
@@ -348,12 +453,6 @@ var BedrockChatLanguageModel = class {
         setting: "seed"
       });
     }
-    if (headers != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "headers"
-      });
-    }
     if (topK != null) {
       warnings.push({
         type: "unsupported-setting",
@@ -368,18 +467,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": {
@@ -387,7 +488,7 @@ 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]
         };
@@ -427,11 +528,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 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 postJsonToApi({
+      url,
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers
+      ),
+      body: args,
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: BedrockErrorSchema,
+        errorToMessage: (error) => {
+          var _a2;
+          return `${(_a2 = error.message) != null ? _a2 : "Unknown error"}`;
+        }
+      }),
+      successfulResponseHandler: 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) => {
@@ -447,48 +566,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 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 postJsonToApi({
+      url,
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers
+      ),
+      body: args,
+      failedResponseHandler: 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);
@@ -529,14 +653,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,
@@ -545,9 +669,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",
@@ -578,99 +702,284 @@ 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 = z2.union([
+  z2.enum(BEDROCK_STOP_REASONS),
+  z2.string()
+]);
+var BedrockToolUseSchema = z2.object({
+  toolUseId: z2.string(),
+  name: z2.string(),
+  input: z2.unknown()
+});
+var BedrockResponseSchema = z2.object({
+  metrics: z2.object({
+    latencyMs: z2.number()
+  }).nullish(),
+  output: z2.object({
+    message: z2.object({
+      content: z2.array(
+        z2.object({
+          text: z2.string().nullish(),
+          toolUse: BedrockToolUseSchema.nullish()
+        })
+      ),
+      role: z2.string()
+    })
+  }),
+  stopReason: BedrockStopReasonSchema,
+  trace: z2.unknown().nullish(),
+  usage: z2.object({
+    inputTokens: z2.number(),
+    outputTokens: z2.number(),
+    totalTokens: z2.number()
+  })
+});
+var BedrockStreamSchema = z2.object({
+  contentBlockDelta: z2.object({
+    contentBlockIndex: z2.number(),
+    delta: z2.union([
+      z2.object({ text: z2.string() }),
+      z2.object({ toolUse: z2.object({ input: z2.string() }) })
+    ]).nullish()
+  }).nullish(),
+  contentBlockStart: z2.object({
+    contentBlockIndex: z2.number(),
+    start: z2.object({
+      toolUse: BedrockToolUseSchema.nullish()
+    }).nullish()
+  }).nullish(),
+  contentBlockStop: z2.object({
+    contentBlockIndex: z2.number()
+  }).nullish(),
+  internalServerException: z2.record(z2.unknown()).nullish(),
+  messageStop: z2.object({
+    additionalModelResponseFields: z2.record(z2.unknown()).nullish(),
+    stopReason: BedrockStopReasonSchema
+  }).nullish(),
+  metadata: z2.object({
+    trace: z2.unknown().nullish(),
+    usage: z2.object({
+      inputTokens: z2.number(),
+      outputTokens: z2.number()
+    }).nullish()
+  }).nullish(),
+  modelStreamErrorException: z2.record(z2.unknown()).nullish(),
+  throttlingException: z2.record(z2.unknown()).nullish(),
+  validationException: z2.record(z2.unknown()).nullish()
+});
 
 // src/bedrock-embedding-model.ts
 import {
-  InvokeModelCommand
-} from "@aws-sdk/client-bedrock-runtime";
+  combineHeaders as combineHeaders2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "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 InvokeModelCommand({
-        contentType: "application/json",
-        body: JSON.stringify(payload),
-        modelId: this.modelId
+      const url = this.getUrl(this.modelId);
+      const { value: response } = await postJsonToApi2({
+        url,
+        headers: await resolve2(
+          combineHeaders2(await resolve2(this.config.headers), headers)
+        ),
+        body: args,
+        failedResponseHandler: createJsonErrorResponseHandler2({
+          errorSchema: BedrockErrorSchema,
+          errorToMessage: (error) => `${error.type}: ${error.message}`
+        }),
+        successfulResponseHandler: createJsonResponseHandler2(
+          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 = z3.object({
+  embedding: z3.array(z3.number()),
+  inputTextTokenCount: z3.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
+import {
+  combineHeaders as combineHeaders3,
+  removeUndefinedEntries
+} from "@ai-sdk/provider-utils";
+import { AwsV4Signer } from "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 AwsV4Signer({
+      url,
+      method: "POST",
+      headers: Object.entries(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: removeUndefinedEntries(
+        combineHeaders3(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: loadSetting({
+        settingValue: options.region,
+        settingName: "region",
+        environmentVariableName: "AWS_REGION",
+        description: "AWS region"
+      }),
+      accessKeyId: loadSetting({
+        settingValue: options.accessKeyId,
+        settingName: "accessKeyId",
+        environmentVariableName: "AWS_ACCESS_KEY_ID",
+        description: "AWS access key ID"
+      }),
+      secretAccessKey: loadSetting({
+        settingValue: options.secretAccessKey,
+        settingName: "secretAccessKey",
+        environmentVariableName: "AWS_SECRET_ACCESS_KEY",
+        description: "AWS secret access key"
+      }),
+      sessionToken: loadOptionalSetting({
+        settingValue: options.sessionToken,
+        environmentVariableName: "AWS_SESSION_TOKEN"
+      })
+    }),
+    options.fetch
+  );
+  const getBaseUrl = () => {
+    var _a, _b;
+    return (_b = withoutTrailingSlash(
+      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${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 BedrockRuntimeClient3(
-      (_a = options.bedrockOptions) != null ? _a : {
-        region: loadSetting({
-          settingValue: options.region,
-          settingName: "region",
-          environmentVariableName: "AWS_REGION",
-          description: "AWS region"
-        }),
-        credentials: {
-          accessKeyId: loadSetting({
-            settingValue: options.accessKeyId,
-            settingName: "accessKeyId",
-            environmentVariableName: "AWS_ACCESS_KEY_ID",
-            description: "AWS access key ID"
-          }),
-          secretAccessKey: loadSetting({
-            settingValue: options.secretAccessKey,
-            settingName: "secretAccessKey",
-            environmentVariableName: "AWS_SECRET_ACCESS_KEY",
-            description: "AWS secret access key"
-          }),
-          sessionToken: loadOptionalSetting({
-            settingValue: options.sessionToken,
-            environmentVariableName: "AWS_SESSION_TOKEN"
-          })
-        }
-      }
-    );
+    return new BedrockChatLanguageModel(modelId, settings, {
+      baseUrl: getBaseUrl,
+      headers: (_a = options.headers) != null ? _a : {},
+      fetch: sigv4Fetch,
+      generateId
+    });
   };
-  const createChatModel = (modelId, settings = {}) => new BedrockChatLanguageModel(modelId, settings, {
-    client: createBedrockRuntimeClient(),
-    generateId
-  });
   const provider = function(modelId, settings) {
     if (new.target) {
       throw new Error(
@@ -679,9 +988,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;