@ai-sdk/amazon-bedrock 5.0.0-beta.8 → 5.0.0-beta.85

package/dist/index.js

@@ -1,40 +1,32 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  bedrock: () => bedrock,
-  createAmazonBedrock: () => createAmazonBedrock
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/bedrock-provider.ts
-var import_internal2 = require("@ai-sdk/anthropic/internal");
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
+// src/amazon-bedrock-provider.ts
+import { anthropicTools as anthropicTools2 } from "@ai-sdk/anthropic/internal";
+import {
+  generateId,
+  loadOptionalSetting,
+  loadSetting,
+  withoutTrailingSlash,
+  withUserAgentSuffix as withUserAgentSuffix2
+} from "@ai-sdk/provider-utils";
 
-// src/bedrock-chat-language-model.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+// src/amazon-bedrock-chat-language-model.ts
+import {
+  combineHeaders,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi,
+  resolve,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { getModelCapabilities } from "@ai-sdk/anthropic/internal";
+import { z as z4 } from "zod/v4";
 
-// src/bedrock-api-types.ts
+// src/amazon-bedrock-api-types.ts
 var BEDROCK_STOP_REASONS = [
   "stop",
   "stop_sequence",
@@ -65,58 +57,73 @@ var BEDROCK_DOCUMENT_MIME_TYPES = {
   "text/markdown": "md"
 };
 
-// src/bedrock-chat-options.ts
-var import_v4 = require("zod/v4");
-var bedrockFilePartProviderOptions = import_v4.z.object({
+// src/amazon-bedrock-chat-language-model-options.ts
+import { z } from "zod/v4";
+var amazonBedrockFilePartProviderOptions = z.object({
   /**
    * Citation configuration for this document.
    * When enabled, this document will generate citations in the response.
    */
-  citations: import_v4.z.object({
+  citations: z.object({
     /**
      * Enable citations for this document
      */
-    enabled: import_v4.z.boolean()
+    enabled: z.boolean()
   }).optional()
 });
-var amazonBedrockLanguageModelOptions = import_v4.z.object({
+var amazonBedrockLanguageModelChatOptions = z.object({
   /**
    * Additional inference parameters that the model supports,
    * beyond the base set of inference parameters that Converse
    * supports in the inferenceConfig field
    */
-  additionalModelRequestFields: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional(),
-  reasoningConfig: import_v4.z.object({
-    type: import_v4.z.union([
-      import_v4.z.literal("enabled"),
-      import_v4.z.literal("disabled"),
-      import_v4.z.literal("adaptive")
+  additionalModelRequestFields: z.record(z.string(), z.any()).optional(),
+  reasoningConfig: z.object({
+    type: z.union([
+      z.literal("enabled"),
+      z.literal("disabled"),
+      z.literal("adaptive")
     ]).optional(),
-    budgetTokens: import_v4.z.number().optional(),
-    maxReasoningEffort: import_v4.z.enum(["low", "medium", "high", "max"]).optional()
+    budgetTokens: z.number().optional(),
+    maxReasoningEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
+    display: z.enum(["omitted", "summarized"]).optional()
   }).optional(),
   /**
    * Anthropic beta features to enable
    */
-  anthropicBeta: import_v4.z.array(import_v4.z.string()).optional()
+  anthropicBeta: z.array(z.string()).optional(),
+  /**
+   * Service tier for the request.
+   * @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
+   *
+   * - 'reserved': Uses provisioned throughput capacity
+   * - 'priority': Prioritizes low-latency inference when capacity is available
+   * - 'default': Standard on-demand tier
+   * - 'flex': Lower-cost tier for flexible latency workloads
+   */
+  serviceTier: z.enum(["reserved", "priority", "default", "flex"]).optional()
 });
 
-// src/bedrock-error.ts
-var import_v42 = require("zod/v4");
-var BedrockErrorSchema = import_v42.z.object({
-  message: import_v42.z.string(),
-  type: import_v42.z.string().nullish()
+// src/amazon-bedrock-error.ts
+import { z as z2 } from "zod/v4";
+var AmazonBedrockErrorSchema = z2.object({
+  message: z2.string(),
+  type: z2.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");
+// src/amazon-bedrock-event-stream-response-handler.ts
+import { EmptyResponseBodyError } from "@ai-sdk/provider";
+import {
+  safeParseJSON,
+  extractResponseHeaders,
+  safeValidateTypes
+} from "@ai-sdk/provider-utils";
 
-// src/bedrock-event-stream-decoder.ts
-var import_eventstream_codec = require("@smithy/eventstream-codec");
-var import_util_utf8 = require("@smithy/util-utf8");
-function createBedrockEventStreamDecoder(body, processEvent) {
-  const codec = new import_eventstream_codec.EventStreamCodec(import_util_utf8.toUtf8, import_util_utf8.fromUtf8);
+// src/amazon-bedrock-event-stream-decoder.ts
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { toUtf8, fromUtf8 } from "@smithy/util-utf8";
+function createAmazonBedrockEventStreamDecoder(body, processEvent) {
+  const codec = new EventStreamCodec(toUtf8, fromUtf8);
   let buffer = new Uint8Array(0);
   const textDecoder = new TextDecoder();
   return body.pipeThrough(
@@ -153,19 +160,19 @@ function createBedrockEventStreamDecoder(body, processEvent) {
   );
 }
 
-// src/bedrock-event-stream-response-handler.ts
-var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response }) => {
-  const responseHeaders = (0, import_provider_utils.extractResponseHeaders)(response);
+// src/amazon-bedrock-event-stream-response-handler.ts
+var createAmazonBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response }) => {
+  const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new import_provider.EmptyResponseBodyError({});
+    throw new EmptyResponseBodyError({});
   }
   return {
     responseHeaders,
-    value: createBedrockEventStreamDecoder(
+    value: createAmazonBedrockEventStreamDecoder(
       response.body,
       async (event, controller) => {
         if (event.messageType === "event") {
-          const parsedDataResult = await (0, import_provider_utils.safeParseJSON)({ text: event.data });
+          const parsedDataResult = await safeParseJSON({ text: event.data });
           if (!parsedDataResult.success) {
             controller.enqueue(parsedDataResult);
             return;
@@ -174,7 +181,7 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
           const wrappedData = {
             [event.eventType]: parsedDataResult.value
           };
-          const validatedWrappedData = await (0, import_provider_utils.safeValidateTypes)({
+          const validatedWrappedData = await safeValidateTypes({
             value: wrappedData,
             schema: chunkSchema
           });
@@ -193,10 +200,15 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
   };
 };
 
-// src/bedrock-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_internal = require("@ai-sdk/anthropic/internal");
+// src/amazon-bedrock-prepare-tools.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import { asSchema } from "@ai-sdk/provider-utils";
+import {
+  anthropicTools,
+  prepareTools as prepareAnthropicTools
+} from "@ai-sdk/anthropic/internal";
 async function prepareTools({
   tools,
   toolChoice,
@@ -236,14 +248,14 @@ async function prepareTools({
   const ProviderTools = supportedTools.filter((t) => t.type === "provider");
   const functionTools = supportedTools.filter((t) => t.type === "function");
   let additionalTools = void 0;
-  const bedrockTools = [];
+  const amazonBedrockTools = [];
   const usingAnthropicTools = isAnthropicModel && ProviderTools.length > 0;
   if (usingAnthropicTools) {
     const {
       toolChoice: preparedAnthropicToolChoice,
       toolWarnings: anthropicToolWarnings,
       betas: anthropicBetas
-    } = await (0, import_internal.prepareTools)({
+    } = await prepareAnthropicTools({
       tools: ProviderTools,
       toolChoice,
       supportsStructuredOutput: false,
@@ -257,17 +269,17 @@ async function prepareTools({
       };
     }
     for (const tool of ProviderTools) {
-      const toolFactory = Object.values(import_internal.anthropicTools).find((factory) => {
+      const toolFactory = Object.values(anthropicTools).find((factory) => {
         const instance = factory({});
         return instance.id === tool.id;
       });
       if (toolFactory != null) {
         const fullToolDefinition = toolFactory({});
-        bedrockTools.push({
+        amazonBedrockTools.push({
           toolSpec: {
             name: tool.name,
             inputSchema: {
-              json: await (0, import_provider_utils2.asSchema)(fullToolDefinition.inputSchema).jsonSchema
+              json: await asSchema(fullToolDefinition.inputSchema).jsonSchema
             }
           }
         });
@@ -282,7 +294,7 @@ async function prepareTools({
   }
   const filteredFunctionTools = (toolChoice == null ? void 0 : toolChoice.type) === "tool" ? functionTools.filter((t) => t.name === toolChoice.toolName) : functionTools;
   for (const tool of filteredFunctionTools) {
-    bedrockTools.push({
+    amazonBedrockTools.push({
       toolSpec: {
         name: tool.name,
         ...((_a = tool.description) == null ? void 0 : _a.trim()) !== "" ? { description: tool.description } : {},
@@ -293,32 +305,32 @@ async function prepareTools({
       }
     });
   }
-  let bedrockToolChoice = void 0;
-  if (!usingAnthropicTools && bedrockTools.length > 0 && toolChoice) {
+  let amazonBedrockToolChoice = void 0;
+  if (!usingAnthropicTools && amazonBedrockTools.length > 0 && toolChoice) {
     const type = toolChoice.type;
     switch (type) {
       case "auto":
-        bedrockToolChoice = { auto: {} };
+        amazonBedrockToolChoice = { auto: {} };
         break;
       case "required":
-        bedrockToolChoice = { any: {} };
+        amazonBedrockToolChoice = { any: {} };
         break;
       case "none":
-        bedrockTools.length = 0;
-        bedrockToolChoice = void 0;
+        amazonBedrockTools.length = 0;
+        amazonBedrockToolChoice = void 0;
         break;
       case "tool":
-        bedrockToolChoice = { tool: { name: toolChoice.toolName } };
+        amazonBedrockToolChoice = { tool: { name: toolChoice.toolName } };
         break;
       default: {
         const _exhaustiveCheck = type;
-        throw new import_provider2.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError({
           functionality: `tool choice type: ${_exhaustiveCheck}`
         });
       }
     }
   }
-  const toolConfig = bedrockTools.length > 0 ? { tools: bedrockTools, toolChoice: bedrockToolChoice } : {};
+  const toolConfig = amazonBedrockTools.length > 0 ? { tools: amazonBedrockTools, toolChoice: amazonBedrockToolChoice } : {};
   return {
     toolConfig,
     additionalTools,
@@ -327,8 +339,8 @@ async function prepareTools({
   };
 }
 
-// src/convert-bedrock-usage.ts
-function convertBedrockUsage(usage) {
+// src/convert-amazon-bedrock-usage.ts
+function convertAmazonBedrockUsage(usage) {
   var _a, _b;
   if (usage == null) {
     return {
@@ -366,9 +378,25 @@ function convertBedrockUsage(usage) {
   };
 }
 
-// src/convert-to-bedrock-chat-messages.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+// src/convert-to-amazon-bedrock-chat-messages.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  getTopLevelMediaType,
+  isFullMediaType,
+  parseProviderOptions,
+  resolveFullMediaType,
+  stripFileExtension
+} from "@ai-sdk/provider-utils";
+
+// src/amazon-bedrock-reasoning-metadata.ts
+import { z as z3 } from "zod/v4";
+var amazonBedrockReasoningMetadataSchema = z3.object({
+  signature: z3.string().optional(),
+  redactedData: z3.string().optional()
+});
 
 // src/normalize-tool-call-id.ts
 function isMistralModel(modelId) {
@@ -382,26 +410,36 @@ function normalizeToolCallId(toolCallId, isMistral) {
   return alphanumericChars.slice(0, 9);
 }
 
-// src/convert-to-bedrock-chat-messages.ts
+// src/convert-to-amazon-bedrock-chat-messages.ts
 function getCachePoint(providerMetadata) {
-  var _a;
-  const cachePointConfig = (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.cachePoint;
+  var _a, _b, _c;
+  const cachePointConfig = (_c = (_a = providerMetadata == null ? void 0 : providerMetadata.amazonBedrock) == null ? void 0 : _a.cachePoint) != null ? _c : (_b = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _b.cachePoint;
   if (!cachePointConfig) {
     return void 0;
   }
   return { cachePoint: cachePointConfig };
 }
+function pushCachePoint(content, providerMetadata) {
+  const cachePoint = getCachePoint(providerMetadata);
+  if (cachePoint) {
+    content.push(cachePoint);
+  }
+}
 async function shouldEnableCitations(providerMetadata) {
-  var _a, _b;
-  const bedrockOptions = await (0, import_provider_utils3.parseProviderOptions)({
+  var _a, _b, _c;
+  const amazonBedrockOptions = (_a = await parseProviderOptions({
+    provider: "amazonBedrock",
+    providerOptions: providerMetadata,
+    schema: amazonBedrockFilePartProviderOptions
+  })) != null ? _a : await parseProviderOptions({
     provider: "bedrock",
     providerOptions: providerMetadata,
-    schema: bedrockFilePartProviderOptions
+    schema: amazonBedrockFilePartProviderOptions
   });
-  return (_b = (_a = bedrockOptions == null ? void 0 : bedrockOptions.citations) == null ? void 0 : _a.enabled) != null ? _b : false;
+  return (_c = (_b = amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.citations) == null ? void 0 : _b.enabled) != null ? _c : false;
 }
-async function convertToBedrockChatMessages(prompt, isMistral = false) {
-  var _a;
+async function convertToAmazonBedrockChatMessages(prompt, isMistral = false) {
+  var _a, _b;
   const blocks = groupIntoBlocks(prompt);
   let system = [];
   const messages = [];
@@ -414,7 +452,7 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
     switch (type) {
       case "system": {
         if (messages.length > 0) {
-          throw new import_provider3.UnsupportedFunctionalityError({
+          throw new UnsupportedFunctionalityError2({
             functionality: "Multiple system messages that are separated by user/assistant messages"
           });
         }
@@ -428,7 +466,7 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
         break;
       }
       case "user": {
-        const bedrockContent = [];
+        const amazonBedrockContent = [];
         for (const message of block.messages) {
           const { role, content, providerOptions } = message;
           switch (role) {
@@ -437,48 +475,79 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                 const part = content[j];
                 switch (part.type) {
                   case "text": {
-                    bedrockContent.push({
+                    amazonBedrockContent.push({
                       text: part.text
                     });
                     break;
                   }
                   case "file": {
-                    if (part.data instanceof URL) {
-                      throw new import_provider3.UnsupportedFunctionalityError({
-                        functionality: "File URL data"
-                      });
-                    }
-                    if (part.mediaType.startsWith("image/")) {
-                      bedrockContent.push({
-                        image: {
-                          format: getBedrockImageFormat(part.mediaType),
-                          source: { bytes: (0, import_provider_utils3.convertToBase64)(part.data) }
-                        }
-                      });
-                    } else {
-                      if (!part.mediaType) {
-                        throw new import_provider3.UnsupportedFunctionalityError({
-                          functionality: "file without mime type",
-                          message: "File mime type is required in user message part content"
+                    switch (part.data.type) {
+                      case "reference": {
+                        throw new UnsupportedFunctionalityError2({
+                          functionality: "file parts with provider references"
                         });
                       }
-                      const enableCitations = await shouldEnableCitations(
-                        part.providerOptions
-                      );
-                      bedrockContent.push({
-                        document: {
-                          format: getBedrockDocumentFormat(part.mediaType),
-                          name: part.filename ? (0, import_provider_utils3.stripFileExtension)(part.filename) : generateDocumentName(),
-                          source: { bytes: (0, import_provider_utils3.convertToBase64)(part.data) },
-                          ...enableCitations && {
-                            citations: { enabled: true }
+                      case "url": {
+                        throw new UnsupportedFunctionalityError2({
+                          functionality: "File URL data"
+                        });
+                      }
+                      case "text": {
+                        const textMediaType = isFullMediaType(part.mediaType) ? part.mediaType : "text/plain";
+                        const enableCitations = await shouldEnableCitations(
+                          part.providerOptions
+                        );
+                        amazonBedrockContent.push({
+                          document: {
+                            format: getAmazonBedrockDocumentFormat(textMediaType),
+                            name: part.filename ? stripFileExtension(part.filename) : generateDocumentName(),
+                            source: {
+                              bytes: convertToBase64(
+                                new TextEncoder().encode(part.data.text)
+                              )
+                            },
+                            ...enableCitations && {
+                              citations: { enabled: true }
+                            }
                           }
+                        });
+                        break;
+                      }
+                      case "data": {
+                        const fullMediaType = resolveFullMediaType({ part });
+                        if (getTopLevelMediaType(fullMediaType) === "image") {
+                          amazonBedrockContent.push({
+                            image: {
+                              format: getAmazonBedrockImageFormat(fullMediaType),
+                              source: {
+                                bytes: convertToBase64(part.data.data)
+                              }
+                            }
+                          });
+                        } else {
+                          const enableCitations = await shouldEnableCitations(
+                            part.providerOptions
+                          );
+                          amazonBedrockContent.push({
+                            document: {
+                              format: getAmazonBedrockDocumentFormat(fullMediaType),
+                              name: part.filename ? stripFileExtension(part.filename) : generateDocumentName(),
+                              source: {
+                                bytes: convertToBase64(part.data.data)
+                              },
+                              ...enableCitations && {
+                                citations: { enabled: true }
+                              }
+                            }
+                          });
                         }
-                      });
+                        break;
+                      }
                     }
                     break;
                   }
                 }
+                pushCachePoint(amazonBedrockContent, part.providerOptions);
               }
               break;
             }
@@ -491,32 +560,58 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                 const output = part.output;
                 switch (output.type) {
                   case "content": {
-                    toolResultContent = output.value.map((contentPart) => {
-                      switch (contentPart.type) {
-                        case "text":
-                          return { text: contentPart.text };
-                        case "image-data":
-                          if (!contentPart.mediaType.startsWith("image/")) {
-                            throw new import_provider3.UnsupportedFunctionalityError({
-                              functionality: `media type: ${contentPart.mediaType}`
+                    toolResultContent = await Promise.all(
+                      output.value.map(async (contentPart) => {
+                        switch (contentPart.type) {
+                          case "text":
+                            return { text: contentPart.text };
+                          case "file": {
+                            if (contentPart.data.type !== "data") {
+                              throw new UnsupportedFunctionalityError2({
+                                functionality: `tool result file data of type "${contentPart.data.type}"`
+                              });
+                            }
+                            const fullMediaType = resolveFullMediaType({
+                              part: contentPart
                             });
-                          }
-                          const format = getBedrockImageFormat(
-                            contentPart.mediaType
-                          );
-                          return {
-                            image: {
-                              format,
-                              source: { bytes: contentPart.data }
+                            if (getTopLevelMediaType(fullMediaType) !== "image") {
+                              const enableCitations = await shouldEnableCitations(
+                                contentPart.providerOptions
+                              );
+                              return {
+                                document: {
+                                  format: getAmazonBedrockDocumentFormat(
+                                    fullMediaType
+                                  ),
+                                  name: contentPart.filename ? stripFileExtension(contentPart.filename) : generateDocumentName(),
+                                  source: {
+                                    bytes: convertToBase64(
+                                      contentPart.data.data
+                                    )
+                                  },
+                                  ...enableCitations && {
+                                    citations: { enabled: true }
+                                  }
+                                }
+                              };
                             }
-                          };
-                        default: {
-                          throw new import_provider3.UnsupportedFunctionalityError({
-                            functionality: `unsupported tool content part type: ${contentPart.type}`
-                          });
+                            return {
+                              image: {
+                                format: getAmazonBedrockImageFormat(fullMediaType),
+                                source: {
+                                  bytes: convertToBase64(contentPart.data.data)
+                                }
+                              }
+                            };
+                          }
+                          default: {
+                            throw new UnsupportedFunctionalityError2({
+                              functionality: `unsupported tool content part type: ${contentPart.type}`
+                            });
+                          }
                         }
-                      }
-                    });
+                      })
+                    );
                     break;
                   }
                   case "text":
@@ -525,7 +620,7 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                     break;
                   case "execution-denied":
                     toolResultContent = [
-                      { text: (_a = output.reason) != null ? _a : "Tool execution denied." }
+                      { text: (_a = output.reason) != null ? _a : "Tool call execution denied." }
                     ];
                     break;
                   case "json":
@@ -536,12 +631,13 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                     ];
                     break;
                 }
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   toolResult: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
                     content: toolResultContent
                   }
                 });
+                pushCachePoint(amazonBedrockContent, part.providerOptions);
               }
               break;
             }
@@ -550,29 +646,29 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
               throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
             }
           }
-          const cachePoint = getCachePoint(providerOptions);
-          if (cachePoint) {
-            bedrockContent.push(cachePoint);
-          }
+          pushCachePoint(amazonBedrockContent, providerOptions);
         }
-        messages.push({ role: "user", content: bedrockContent });
+        messages.push({ role: "user", content: amazonBedrockContent });
         break;
       }
       case "assistant": {
-        const bedrockContent = [];
+        const amazonBedrockContent = [];
         for (let j = 0; j < block.messages.length; j++) {
           const message = block.messages[j];
           const isLastMessage = j === block.messages.length - 1;
           const { content } = message;
+          const hasReasoningBlocks = content.some(
+            (part) => part.type === "reasoning"
+          );
           for (let k = 0; k < content.length; k++) {
             const part = content[k];
             const isLastContentPart = k === content.length - 1;
             switch (part.type) {
               case "text": {
-                if (!part.text.trim()) {
+                if (!part.text.trim() && !hasReasoningBlocks) {
                   break;
                 }
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   text: (
                     // trim the last text part if it's the last message in the block
                     // because Bedrock does not allow trailing whitespace
@@ -588,43 +684,37 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                 break;
               }
               case "reasoning": {
-                const reasoningMetadata = await (0, import_provider_utils3.parseProviderOptions)({
+                const reasoningMetadata = (_b = await parseProviderOptions({
+                  provider: "amazonBedrock",
+                  providerOptions: part.providerOptions,
+                  schema: amazonBedrockReasoningMetadataSchema
+                })) != null ? _b : await parseProviderOptions({
                   provider: "bedrock",
                   providerOptions: part.providerOptions,
-                  schema: bedrockReasoningMetadataSchema
+                  schema: amazonBedrockReasoningMetadataSchema
                 });
-                if (reasoningMetadata != null) {
-                  if (reasoningMetadata.signature != null) {
-                    bedrockContent.push({
-                      reasoningContent: {
-                        reasoningText: {
-                          // trim the last text part if it's the last message in the block
-                          // because Bedrock does not allow trailing whitespace
-                          // in pre-filled assistant responses
-                          text: trimIfLast(
-                            isLastBlock,
-                            isLastMessage,
-                            isLastContentPart,
-                            part.text
-                          ),
-                          signature: reasoningMetadata.signature
-                        }
+                if ((reasoningMetadata == null ? void 0 : reasoningMetadata.signature) != null) {
+                  amazonBedrockContent.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: part.text,
+                        signature: reasoningMetadata.signature
                       }
-                    });
-                  } else if (reasoningMetadata.redactedData != null) {
-                    bedrockContent.push({
-                      reasoningContent: {
-                        redactedReasoning: {
-                          data: reasoningMetadata.redactedData
-                        }
+                    }
+                  });
+                } else if ((reasoningMetadata == null ? void 0 : reasoningMetadata.redactedData) != null) {
+                  amazonBedrockContent.push({
+                    reasoningContent: {
+                      redactedReasoning: {
+                        data: reasoningMetadata.redactedData
                       }
-                    });
-                  }
+                    }
+                  });
                 }
                 break;
               }
               case "tool-call": {
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   toolUse: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
                     name: part.toolName,
@@ -634,13 +724,11 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                 break;
               }
             }
+            pushCachePoint(amazonBedrockContent, part.providerOptions);
           }
-          const cachePoint = getCachePoint(message.providerOptions);
-          if (cachePoint) {
-            bedrockContent.push(cachePoint);
-          }
+          pushCachePoint(amazonBedrockContent, message.providerOptions);
         }
-        messages.push({ role: "assistant", content: bedrockContent });
+        messages.push({ role: "assistant", content: amazonBedrockContent });
         break;
       }
       default: {
@@ -651,26 +739,20 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
   }
   return { system, messages };
 }
-function getBedrockImageFormat(mimeType) {
-  if (!mimeType) {
-    throw new import_provider3.UnsupportedFunctionalityError({
-      functionality: "image without mime type",
-      message: "Image mime type is required in user message part content"
-    });
-  }
+function getAmazonBedrockImageFormat(mimeType) {
   const format = BEDROCK_IMAGE_MIME_TYPES[mimeType];
   if (!format) {
-    throw new import_provider3.UnsupportedFunctionalityError({
+    throw new UnsupportedFunctionalityError2({
       functionality: `image mime type: ${mimeType}`,
       message: `Unsupported image mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_IMAGE_MIME_TYPES).join(", ")}`
     });
   }
   return format;
 }
-function getBedrockDocumentFormat(mimeType) {
+function getAmazonBedrockDocumentFormat(mimeType) {
   const format = BEDROCK_DOCUMENT_MIME_TYPES[mimeType];
   if (!format) {
-    throw new import_provider3.UnsupportedFunctionalityError({
+    throw new UnsupportedFunctionalityError2({
       functionality: `file mime type: ${mimeType}`,
       message: `Unsupported file mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_DOCUMENT_MIME_TYPES).join(", ")}`
     });
@@ -727,8 +809,8 @@ function groupIntoBlocks(prompt) {
   return blocks;
 }
 
-// src/map-bedrock-finish-reason.ts
-function mapBedrockFinishReason(finishReason, isJsonResponseFromTool) {
+// src/map-amazon-bedrock-finish-reason.ts
+function mapAmazonBedrockFinishReason(finishReason, isJsonResponseFromTool) {
   switch (finishReason) {
     case "stop_sequence":
     case "end_turn":
@@ -745,8 +827,8 @@ function mapBedrockFinishReason(finishReason, isJsonResponseFromTool) {
   }
 }
 
-// src/bedrock-chat-language-model.ts
-var BedrockChatLanguageModel = class {
+// src/amazon-bedrock-chat-language-model.ts
+var AmazonBedrockChatLanguageModel = class _AmazonBedrockChatLanguageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
@@ -756,6 +838,15 @@ var BedrockChatLanguageModel = class {
       // no supported urls for bedrock
     };
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _AmazonBedrockChatLanguageModel(options.modelId, options.config);
+  }
   async getArgs({
     prompt,
     maxOutputTokens,
@@ -769,14 +860,19 @@ var BedrockChatLanguageModel = class {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions
   }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-    const bedrockOptions = (_a = await (0, import_provider_utils4.parseProviderOptions)({
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    let amazonBedrockOptions = (_b = (_a = await parseProviderOptions2({
+      provider: "amazonBedrock",
+      providerOptions,
+      schema: amazonBedrockLanguageModelChatOptions
+    })) != null ? _a : await parseProviderOptions2({
       provider: "bedrock",
       providerOptions,
-      schema: amazonBedrockLanguageModelOptions
-    })) != null ? _a : {};
+      schema: amazonBedrockLanguageModelChatOptions
+    })) != null ? _b : {};
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({
@@ -819,8 +915,17 @@ var BedrockChatLanguageModel = class {
       });
     }
     const isAnthropicModel = this.modelId.includes("anthropic");
-    const isThinkingEnabled = ((_b = bedrockOptions.reasoningConfig) == null ? void 0 : _b.type) === "enabled" || ((_c = bedrockOptions.reasoningConfig) == null ? void 0 : _c.type) === "adaptive";
-    const useNativeStructuredOutput = isAnthropicModel && isThinkingEnabled && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null;
+    const isOpenAIModel = this.modelId.startsWith("openai.");
+    amazonBedrockOptions = resolveAmazonBedrockReasoningConfig({
+      reasoning,
+      amazonBedrockOptions,
+      warnings,
+      isAnthropicModel,
+      modelId: this.modelId
+    });
+    const isThinkingEnabled = ((_c = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _c.type) === "enabled" || ((_d = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _d.type) === "adaptive";
+    const { supportsStructuredOutput: modelSupportsStructuredOutput } = getModelCapabilities(this.modelId);
+    const useNativeStructuredOutput = isAnthropicModel && (modelSupportsStructuredOutput || isThinkingEnabled) && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null;
     const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !useNativeStructuredOutput ? {
       type: "function",
       name: "json",
@@ -834,21 +939,22 @@ var BedrockChatLanguageModel = class {
     });
     warnings.push(...toolWarnings);
     if (additionalTools) {
-      bedrockOptions.additionalModelRequestFields = {
-        ...bedrockOptions.additionalModelRequestFields,
+      amazonBedrockOptions.additionalModelRequestFields = {
+        ...amazonBedrockOptions.additionalModelRequestFields,
         ...additionalTools
       };
     }
-    if (betas.size > 0 || bedrockOptions.anthropicBeta) {
-      const existingBetas = (_d = bedrockOptions.anthropicBeta) != null ? _d : [];
+    if (betas.size > 0 || amazonBedrockOptions.anthropicBeta) {
+      const existingBetas = (_e = amazonBedrockOptions.anthropicBeta) != null ? _e : [];
       const mergedBetas = betas.size > 0 ? [...existingBetas, ...Array.from(betas)] : existingBetas;
-      bedrockOptions.additionalModelRequestFields = {
-        ...bedrockOptions.additionalModelRequestFields,
+      amazonBedrockOptions.additionalModelRequestFields = {
+        ...amazonBedrockOptions.additionalModelRequestFields,
         anthropic_beta: mergedBetas
       };
     }
-    const thinkingType = (_e = bedrockOptions.reasoningConfig) == null ? void 0 : _e.type;
-    const thinkingBudget = thinkingType === "enabled" ? (_f = bedrockOptions.reasoningConfig) == null ? void 0 : _f.budgetTokens : void 0;
+    const thinkingType = (_f = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _f.type;
+    const thinkingBudget = thinkingType === "enabled" ? (_g = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _g.budgetTokens : void 0;
+    const thinkingDisplay = thinkingType === "adaptive" ? (_h = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _h.display : void 0;
     const isAnthropicThinkingEnabled = isAnthropicModel && isThinkingEnabled;
     const inferenceConfig = {
       ...maxOutputTokens != null && { maxTokens: maxOutputTokens },
@@ -864,23 +970,24 @@ var BedrockChatLanguageModel = class {
         } else {
           inferenceConfig.maxTokens = thinkingBudget + 4096;
         }
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           thinking: {
             type: "enabled",
             budget_tokens: thinkingBudget
           }
         };
       } else if (thinkingType === "adaptive") {
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           thinking: {
-            type: "adaptive"
+            type: "adaptive",
+            ...thinkingDisplay != null && { display: thinkingDisplay }
           }
         };
       }
     } else if (!isAnthropicModel) {
-      if (((_g = bedrockOptions.reasoningConfig) == null ? void 0 : _g.budgetTokens) != null) {
+      if (((_i = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _i.budgetTokens) != null) {
         warnings.push({
           type: "unsupported",
           feature: "budgetTokens",
@@ -895,25 +1002,24 @@ var BedrockChatLanguageModel = class {
         });
       }
     }
-    const maxReasoningEffort = (_h = bedrockOptions.reasoningConfig) == null ? void 0 : _h.maxReasoningEffort;
-    const isOpenAIModel = this.modelId.startsWith("openai.");
+    const maxReasoningEffort = (_j = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _j.maxReasoningEffort;
     if (maxReasoningEffort != null) {
       if (isAnthropicModel) {
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           output_config: {
-            ...(_i = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _i.output_config,
+            ...(_k = amazonBedrockOptions.additionalModelRequestFields) == null ? void 0 : _k.output_config,
             effort: maxReasoningEffort
           }
         };
       } else if (isOpenAIModel) {
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           reasoning_effort: maxReasoningEffort
         };
       } else {
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           reasoningConfig: {
             ...thinkingType != null && thinkingType !== "adaptive" && { type: thinkingType },
             ...thinkingBudget != null && { budgetTokens: thinkingBudget },
@@ -923,10 +1029,10 @@ var BedrockChatLanguageModel = class {
       }
     }
     if (useNativeStructuredOutput) {
-      bedrockOptions.additionalModelRequestFields = {
-        ...bedrockOptions.additionalModelRequestFields,
+      amazonBedrockOptions.additionalModelRequestFields = {
+        ...amazonBedrockOptions.additionalModelRequestFields,
         output_config: {
-          ...(_j = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _j.output_config,
+          ...(_l = amazonBedrockOptions.additionalModelRequestFields) == null ? void 0 : _l.output_config,
           format: {
             type: "json_schema",
             schema: responseFormat.schema
@@ -958,7 +1064,7 @@ var BedrockChatLanguageModel = class {
         details: "topK is not supported when thinking is enabled"
       });
     }
-    const hasAnyTools = ((_l = (_k = toolConfig.tools) == null ? void 0 : _k.length) != null ? _l : 0) > 0 || additionalTools;
+    const hasAnyTools = ((_n = (_m = toolConfig.tools) == null ? void 0 : _m.length) != null ? _n : 0) > 0 || additionalTools;
     let filteredPrompt = prompt;
     if (!hasAnyTools) {
       const hasToolContent = prompt.some(
@@ -985,28 +1091,34 @@ var BedrockChatLanguageModel = class {
       }
     }
     const isMistral = isMistralModel(this.modelId);
-    const { system, messages } = await convertToBedrockChatMessages(
+    const { system, messages } = await convertToAmazonBedrockChatMessages(
       filteredPrompt,
       isMistral
     );
     const {
       reasoningConfig: _,
       additionalModelRequestFields: __,
-      ...filteredBedrockOptions
-    } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
+      serviceTier: ___,
+      ...filteredAmazonBedrockOptions
+    } = (_p = (_o = providerOptions == null ? void 0 : providerOptions.amazonBedrock) != null ? _o : providerOptions == null ? void 0 : providerOptions.bedrock) != null ? _p : {};
     const additionalModelResponseFieldPaths = isAnthropicModel ? ["/delta/stop_sequence"] : void 0;
     return {
       command: {
         system,
         messages,
-        additionalModelRequestFields: bedrockOptions.additionalModelRequestFields,
+        additionalModelRequestFields: amazonBedrockOptions.additionalModelRequestFields,
         ...additionalModelResponseFieldPaths && {
           additionalModelResponseFieldPaths
         },
         ...Object.keys(inferenceConfig).length > 0 && {
           inferenceConfig
         },
-        ...filteredBedrockOptions,
+        ...amazonBedrockOptions.serviceTier != null && {
+          serviceTier: {
+            type: amazonBedrockOptions.serviceTier
+          }
+        },
+        ...filteredAmazonBedrockOptions,
         ...toolConfig.tools !== void 0 && toolConfig.tools.length > 0 ? { toolConfig } : {}
       },
       warnings,
@@ -1017,7 +1129,10 @@ var BedrockChatLanguageModel = class {
   async getHeaders({
     headers
   }) {
-    return (0, import_provider_utils4.combineHeaders)(await (0, import_provider_utils4.resolve)(this.config.headers), headers);
+    return combineHeaders(
+      this.config.headers ? await resolve(this.config.headers) : void 0,
+      headers
+    );
   }
   async doGenerate(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
@@ -1027,19 +1142,19 @@ var BedrockChatLanguageModel = class {
       usesJsonResponseTool
     } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse`;
-    const { value: response, responseHeaders } = await (0, import_provider_utils4.postJsonToApi)({
+    const { value: response, responseHeaders } = await postJsonToApi({
       url,
       headers: await this.getHeaders({ headers: options.headers }),
       body: args,
-      failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
-        errorSchema: BedrockErrorSchema,
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: (error) => {
           var _a2;
           return `${(_a2 = error.message) != null ? _a2 : "Unknown error"}`;
         }
       }),
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
-        BedrockResponseSchema
+      successfulResponseHandler: createJsonResponseHandler(
+        AmazonBedrockResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -1047,7 +1162,7 @@ var BedrockChatLanguageModel = class {
     const content = [];
     let isJsonResponseFromTool = false;
     for (const part of response.output.message.content) {
-      if (part.text) {
+      if (part.text != null) {
         content.push({ type: "text", text: part.text });
       }
       if (part.reasoningContent) {
@@ -1057,21 +1172,25 @@ var BedrockChatLanguageModel = class {
             text: part.reasoningContent.reasoningText.text
           };
           if (part.reasoningContent.reasoningText.signature) {
+            const reasoningPayload = {
+              signature: part.reasoningContent.reasoningText.signature
+            };
             reasoning.providerMetadata = {
-              bedrock: {
-                signature: part.reasoningContent.reasoningText.signature
-              }
+              amazonBedrock: reasoningPayload,
+              bedrock: reasoningPayload
             };
           }
           content.push(reasoning);
         } else if ("redactedReasoning" in part.reasoningContent) {
+          const redactedPayload = {
+            redactedData: (_a = part.reasoningContent.redactedReasoning.data) != null ? _a : ""
+          };
           content.push({
             type: "reasoning",
             text: "",
             providerMetadata: {
-              bedrock: {
-                redactedData: (_a = part.reasoningContent.redactedReasoning.data) != null ? _a : ""
-              }
+              amazonBedrock: redactedPayload,
+              bedrock: redactedPayload
             }
           });
         }
@@ -1097,39 +1216,41 @@ var BedrockChatLanguageModel = class {
       }
     }
     const stopSequence = (_j = (_i = (_h = response.additionalModelResponseFields) == null ? void 0 : _h.delta) == null ? void 0 : _i.stop_sequence) != null ? _j : null;
-    const providerMetadata = response.trace || response.usage || response.performanceConfig || response.serviceTier || isJsonResponseFromTool || stopSequence ? {
-      bedrock: {
-        ...response.trace && typeof response.trace === "object" ? { trace: response.trace } : {},
-        ...response.performanceConfig && {
-          performanceConfig: response.performanceConfig
-        },
-        ...response.serviceTier && {
-          serviceTier: response.serviceTier
-        },
-        ...(((_k = response.usage) == null ? void 0 : _k.cacheWriteInputTokens) != null || ((_l = response.usage) == null ? void 0 : _l.cacheDetails) != null) && {
-          usage: {
-            ...response.usage.cacheWriteInputTokens != null && {
-              cacheWriteInputTokens: response.usage.cacheWriteInputTokens
-            },
-            ...response.usage.cacheDetails != null && {
-              cacheDetails: response.usage.cacheDetails
-            }
+    const providerMetadataPayload = response.trace || response.usage || response.performanceConfig || response.serviceTier || isJsonResponseFromTool || stopSequence ? {
+      ...response.trace && typeof response.trace === "object" ? { trace: response.trace } : {},
+      ...response.performanceConfig && {
+        performanceConfig: response.performanceConfig
+      },
+      ...response.serviceTier && {
+        serviceTier: response.serviceTier
+      },
+      ...(((_k = response.usage) == null ? void 0 : _k.cacheWriteInputTokens) != null || ((_l = response.usage) == null ? void 0 : _l.cacheDetails) != null) && {
+        usage: {
+          ...response.usage.cacheWriteInputTokens != null && {
+            cacheWriteInputTokens: response.usage.cacheWriteInputTokens
+          },
+          ...response.usage.cacheDetails != null && {
+            cacheDetails: response.usage.cacheDetails
           }
-        },
-        ...isJsonResponseFromTool && { isJsonResponseFromTool: true },
-        stopSequence
-      }
+        }
+      },
+      ...isJsonResponseFromTool && { isJsonResponseFromTool: true },
+      stopSequence
+    } : void 0;
+    const providerMetadata = providerMetadataPayload ? {
+      amazonBedrock: providerMetadataPayload,
+      bedrock: providerMetadataPayload
     } : void 0;
     return {
       content,
       finishReason: {
-        unified: mapBedrockFinishReason(
+        unified: mapAmazonBedrockFinishReason(
           response.stopReason,
           isJsonResponseFromTool
         ),
         raw: (_m = response.stopReason) != null ? _m : void 0
       },
-      usage: convertBedrockUsage(response.usage),
+      usage: convertAmazonBedrockUsage(response.usage),
       response: {
         id: (_n = responseHeaders == null ? void 0 : responseHeaders["x-amzn-requestid"]) != null ? _n : void 0,
         timestamp: (responseHeaders == null ? void 0 : responseHeaders["date"]) != null ? new Date(responseHeaders["date"]) : void 0,
@@ -1149,15 +1270,17 @@ var BedrockChatLanguageModel = class {
     const modelId = this.modelId;
     const isMistral = isMistralModel(modelId);
     const url = `${this.getUrl(modelId)}/converse-stream`;
-    const { value: response, responseHeaders } = await (0, import_provider_utils4.postJsonToApi)({
+    const { value: response, responseHeaders } = await postJsonToApi({
       url,
       headers: await this.getHeaders({ headers: options.headers }),
       body: args,
-      failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
-        errorSchema: BedrockErrorSchema,
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: createBedrockEventStreamResponseHandler(BedrockStreamSchema),
+      successfulResponseHandler: createAmazonBedrockEventStreamResponseHandler(
+        AmazonBedrockStreamSchema
+      ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -1185,9 +1308,9 @@ var BedrockChatLanguageModel = class {
           },
           transform(chunk, controller) {
             var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
-            function enqueueError(bedrockError) {
+            function enqueueError(amazonBedrockError) {
               finishReason = { unified: "error", raw: void 0 };
-              controller.enqueue({ type: "error", error: bedrockError });
+              controller.enqueue({ type: "error", error: amazonBedrockError });
             }
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
@@ -1215,7 +1338,7 @@ var BedrockChatLanguageModel = class {
             }
             if (value.messageStop) {
               finishReason = {
-                unified: mapBedrockFinishReason(
+                unified: mapAmazonBedrockFinishReason(
                   value.messageStop.stopReason,
                   isJsonResponseFromTool
                 ),
@@ -1241,18 +1364,20 @@ var BedrockChatLanguageModel = class {
                 trace: value.metadata.trace
               } : void 0;
               if (cacheUsage || trace || value.metadata.performanceConfig || value.metadata.serviceTier) {
-                providerMetadata = {
-                  bedrock: {
-                    ...cacheUsage,
-                    ...trace,
-                    ...value.metadata.performanceConfig && {
-                      performanceConfig: value.metadata.performanceConfig
-                    },
-                    ...value.metadata.serviceTier && {
-                      serviceTier: value.metadata.serviceTier
-                    }
+                const metadataPayload = {
+                  ...cacheUsage,
+                  ...trace,
+                  ...value.metadata.performanceConfig && {
+                    performanceConfig: value.metadata.performanceConfig
+                  },
+                  ...value.metadata.serviceTier && {
+                    serviceTier: value.metadata.serviceTier
                   }
                 };
+                providerMetadata = {
+                  amazonBedrock: metadataPayload,
+                  bedrock: metadataPayload
+                };
               }
             }
             if (((_i = value.contentBlockStart) == null ? void 0 : _i.contentBlockIndex) != null && !((_k = (_j = value.contentBlockStart) == null ? void 0 : _j.start) == null ? void 0 : _k.toolUse)) {
@@ -1341,27 +1466,49 @@ var BedrockChatLanguageModel = class {
                   delta: reasoningContent.text
                 });
               } else if ("signature" in reasoningContent && reasoningContent.signature) {
-                controller.enqueue({
-                  type: "reasoning-delta",
-                  id: String(blockIndex),
-                  delta: "",
-                  providerMetadata: {
-                    bedrock: {
-                      signature: reasoningContent.signature
+                if (contentBlocks[blockIndex] == null) {
+                  contentBlocks[blockIndex] = { type: "reasoning" };
+                  controller.enqueue({
+                    type: "reasoning-start",
+                    id: String(blockIndex)
+                  });
+                }
+                {
+                  const signaturePayload = {
+                    signature: reasoningContent.signature
+                  };
+                  controller.enqueue({
+                    type: "reasoning-delta",
+                    id: String(blockIndex),
+                    delta: "",
+                    providerMetadata: {
+                      amazonBedrock: signaturePayload,
+                      bedrock: signaturePayload
                     }
-                  }
-                });
+                  });
+                }
               } else if ("data" in reasoningContent && reasoningContent.data) {
-                controller.enqueue({
-                  type: "reasoning-delta",
-                  id: String(blockIndex),
-                  delta: "",
-                  providerMetadata: {
-                    bedrock: {
-                      redactedData: reasoningContent.data
+                if (contentBlocks[blockIndex] == null) {
+                  contentBlocks[blockIndex] = { type: "reasoning" };
+                  controller.enqueue({
+                    type: "reasoning-start",
+                    id: String(blockIndex)
+                  });
+                }
+                {
+                  const redactedPayload = {
+                    redactedData: reasoningContent.data
+                  };
+                  controller.enqueue({
+                    type: "reasoning-delta",
+                    id: String(blockIndex),
+                    delta: "",
+                    providerMetadata: {
+                      amazonBedrock: redactedPayload,
+                      bedrock: redactedPayload
                     }
-                  }
-                });
+                  });
+                }
               }
             }
             const contentBlockStart = value.contentBlockStart;
@@ -1406,30 +1553,25 @@ var BedrockChatLanguageModel = class {
             }
           },
           flush(controller) {
+            var _a;
             if (isJsonResponseFromTool || stopSequence != null) {
-              if (providerMetadata) {
-                providerMetadata.bedrock = {
-                  ...providerMetadata.bedrock,
-                  ...isJsonResponseFromTool && {
-                    isJsonResponseFromTool: true
-                  },
-                  stopSequence
-                };
-              } else {
-                providerMetadata = {
-                  bedrock: {
-                    ...isJsonResponseFromTool && {
-                      isJsonResponseFromTool: true
-                    },
-                    stopSequence
-                  }
-                };
-              }
+              const updatePayload = {
+                ...(_a = providerMetadata == null ? void 0 : providerMetadata.amazonBedrock) != null ? _a : providerMetadata == null ? void 0 : providerMetadata.bedrock,
+                ...isJsonResponseFromTool && {
+                  isJsonResponseFromTool: true
+                },
+                stopSequence
+              };
+              providerMetadata = {
+                ...providerMetadata,
+                amazonBedrock: updatePayload,
+                bedrock: updatePayload
+              };
             }
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage: convertBedrockUsage(usage),
+              usage: convertAmazonBedrockUsage(usage),
               ...providerMetadata && { providerMetadata }
             });
           }
@@ -1444,146 +1586,220 @@ var BedrockChatLanguageModel = class {
     return `${this.config.baseUrl()}/model/${encodedModelId}`;
   }
 };
-var BedrockStopReasonSchema = import_v43.z.union([
-  import_v43.z.enum(BEDROCK_STOP_REASONS),
-  import_v43.z.string()
+var AmazonBedrockStopReasonSchema = z4.union([
+  z4.enum(BEDROCK_STOP_REASONS),
+  z4.string()
 ]);
-var BedrockAdditionalModelResponseFieldsSchema = import_v43.z.object({
-  delta: import_v43.z.object({
-    stop_sequence: import_v43.z.string().nullish()
+var AmazonBedrockAdditionalModelResponseFieldsSchema = z4.object({
+  delta: z4.object({
+    stop_sequence: z4.string().nullish()
   }).nullish()
-}).catchall(import_v43.z.unknown());
-var BedrockToolUseSchema = import_v43.z.object({
-  toolUseId: import_v43.z.string(),
-  name: import_v43.z.string(),
-  input: import_v43.z.unknown()
+}).catchall(z4.unknown());
+var AmazonBedrockToolUseSchema = z4.object({
+  toolUseId: z4.string(),
+  name: z4.string(),
+  input: z4.unknown().optional()
 });
-var BedrockReasoningTextSchema = import_v43.z.object({
-  signature: import_v43.z.string().nullish(),
-  text: import_v43.z.string()
+var AmazonBedrockReasoningTextSchema = z4.object({
+  signature: z4.string().nullish(),
+  text: z4.string()
 });
-var BedrockRedactedReasoningSchema = import_v43.z.object({
-  data: import_v43.z.string()
+var AmazonBedrockRedactedReasoningSchema = z4.object({
+  data: z4.string()
 });
-var BedrockResponseSchema = import_v43.z.object({
-  metrics: import_v43.z.object({
-    latencyMs: import_v43.z.number()
+var AmazonBedrockResponseSchema = z4.object({
+  metrics: z4.object({
+    latencyMs: z4.number()
   }).nullish(),
-  output: import_v43.z.object({
-    message: import_v43.z.object({
-      content: import_v43.z.array(
-        import_v43.z.object({
-          text: import_v43.z.string().nullish(),
-          toolUse: BedrockToolUseSchema.nullish(),
-          reasoningContent: import_v43.z.union([
-            import_v43.z.object({
-              reasoningText: BedrockReasoningTextSchema
+  output: z4.object({
+    message: z4.object({
+      content: z4.array(
+        z4.object({
+          text: z4.string().nullish(),
+          toolUse: AmazonBedrockToolUseSchema.nullish(),
+          reasoningContent: z4.union([
+            z4.object({
+              reasoningText: AmazonBedrockReasoningTextSchema
             }),
-            import_v43.z.object({
-              redactedReasoning: BedrockRedactedReasoningSchema
+            z4.object({
+              redactedReasoning: AmazonBedrockRedactedReasoningSchema
             })
           ]).nullish()
         })
       ),
-      role: import_v43.z.string()
+      role: z4.string()
     })
   }),
-  stopReason: BedrockStopReasonSchema,
-  additionalModelResponseFields: BedrockAdditionalModelResponseFieldsSchema.nullish(),
-  trace: import_v43.z.unknown().nullish(),
-  performanceConfig: import_v43.z.object({ latency: import_v43.z.string() }).nullish(),
-  serviceTier: import_v43.z.object({ type: import_v43.z.string() }).nullish(),
-  usage: import_v43.z.object({
-    inputTokens: import_v43.z.number(),
-    outputTokens: import_v43.z.number(),
-    totalTokens: import_v43.z.number(),
-    cacheReadInputTokens: import_v43.z.number().nullish(),
-    cacheWriteInputTokens: import_v43.z.number().nullish(),
-    cacheDetails: import_v43.z.array(import_v43.z.object({ inputTokens: import_v43.z.number(), ttl: import_v43.z.string() })).nullish()
+  stopReason: AmazonBedrockStopReasonSchema,
+  additionalModelResponseFields: AmazonBedrockAdditionalModelResponseFieldsSchema.nullish(),
+  trace: z4.unknown().nullish(),
+  performanceConfig: z4.object({ latency: z4.string() }).nullish(),
+  serviceTier: z4.object({ type: z4.string() }).nullish(),
+  usage: z4.object({
+    inputTokens: z4.number(),
+    outputTokens: z4.number(),
+    totalTokens: z4.number(),
+    cacheReadInputTokens: z4.number().nullish(),
+    cacheWriteInputTokens: z4.number().nullish(),
+    cacheDetails: z4.array(z4.object({ inputTokens: z4.number(), ttl: z4.string() })).nullish()
   })
 });
-var BedrockStreamSchema = import_v43.z.object({
-  contentBlockDelta: import_v43.z.object({
-    contentBlockIndex: import_v43.z.number(),
-    delta: import_v43.z.union([
-      import_v43.z.object({ text: import_v43.z.string() }),
-      import_v43.z.object({ toolUse: import_v43.z.object({ input: import_v43.z.string() }) }),
-      import_v43.z.object({
-        reasoningContent: import_v43.z.object({ text: import_v43.z.string() })
+var AmazonBedrockStreamSchema = z4.object({
+  contentBlockDelta: z4.object({
+    contentBlockIndex: z4.number(),
+    delta: z4.union([
+      z4.object({ text: z4.string() }),
+      z4.object({ toolUse: z4.object({ input: z4.string() }) }),
+      z4.object({
+        reasoningContent: z4.object({ text: z4.string() })
       }),
-      import_v43.z.object({
-        reasoningContent: import_v43.z.object({
-          signature: import_v43.z.string()
+      z4.object({
+        reasoningContent: z4.object({
+          signature: z4.string()
         })
       }),
-      import_v43.z.object({
-        reasoningContent: import_v43.z.object({ data: import_v43.z.string() })
+      z4.object({
+        reasoningContent: z4.object({ data: z4.string() })
       })
     ]).nullish()
   }).nullish(),
-  contentBlockStart: import_v43.z.object({
-    contentBlockIndex: import_v43.z.number(),
-    start: import_v43.z.object({
-      toolUse: BedrockToolUseSchema.nullish()
+  contentBlockStart: z4.object({
+    contentBlockIndex: z4.number(),
+    start: z4.object({
+      toolUse: AmazonBedrockToolUseSchema.nullish()
     }).nullish()
   }).nullish(),
-  contentBlockStop: import_v43.z.object({
-    contentBlockIndex: import_v43.z.number()
+  contentBlockStop: z4.object({
+    contentBlockIndex: z4.number()
   }).nullish(),
-  internalServerException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
-  messageStop: import_v43.z.object({
-    additionalModelResponseFields: BedrockAdditionalModelResponseFieldsSchema.nullish(),
-    stopReason: BedrockStopReasonSchema
+  internalServerException: z4.record(z4.string(), z4.unknown()).nullish(),
+  messageStop: z4.object({
+    additionalModelResponseFields: AmazonBedrockAdditionalModelResponseFieldsSchema.nullish(),
+    stopReason: AmazonBedrockStopReasonSchema
   }).nullish(),
-  metadata: import_v43.z.object({
-    trace: import_v43.z.unknown().nullish(),
-    performanceConfig: import_v43.z.object({ latency: import_v43.z.string() }).nullish(),
-    serviceTier: import_v43.z.object({ type: import_v43.z.string() }).nullish(),
-    usage: import_v43.z.object({
-      cacheReadInputTokens: import_v43.z.number().nullish(),
-      cacheWriteInputTokens: import_v43.z.number().nullish(),
-      cacheDetails: import_v43.z.array(import_v43.z.object({ inputTokens: import_v43.z.number(), ttl: import_v43.z.string() })).nullish(),
-      inputTokens: import_v43.z.number(),
-      outputTokens: import_v43.z.number()
+  metadata: z4.object({
+    trace: z4.unknown().nullish(),
+    performanceConfig: z4.object({ latency: z4.string() }).nullish(),
+    serviceTier: z4.object({ type: z4.string() }).nullish(),
+    usage: z4.object({
+      cacheReadInputTokens: z4.number().nullish(),
+      cacheWriteInputTokens: z4.number().nullish(),
+      cacheDetails: z4.array(z4.object({ inputTokens: z4.number(), ttl: z4.string() })).nullish(),
+      inputTokens: z4.number(),
+      outputTokens: z4.number()
     }).nullish()
   }).nullish(),
-  modelStreamErrorException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
-  throttlingException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
-  validationException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish()
-});
-var bedrockReasoningMetadataSchema = import_v43.z.object({
-  signature: import_v43.z.string().optional(),
-  redactedData: import_v43.z.string().optional()
+  modelStreamErrorException: z4.record(z4.string(), z4.unknown()).nullish(),
+  throttlingException: z4.record(z4.string(), z4.unknown()).nullish(),
+  validationException: z4.record(z4.string(), z4.unknown()).nullish()
 });
+var amazonBedrockReasoningEffortMap = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max"
+};
+function resolveAmazonBedrockReasoningConfig({
+  reasoning,
+  amazonBedrockOptions,
+  warnings,
+  isAnthropicModel,
+  modelId
+}) {
+  var _a;
+  if (!isCustomReasoning(reasoning)) {
+    return amazonBedrockOptions;
+  }
+  const result = { ...amazonBedrockOptions };
+  if (isAnthropicModel) {
+    const capabilities = getModelCapabilities(modelId);
+    if (reasoning === "none") {
+      result.reasoningConfig = { type: "disabled" };
+    } else if (capabilities.supportsAdaptiveThinking) {
+      const effort = mapReasoningToProviderEffort({
+        reasoning,
+        effortMap: amazonBedrockReasoningEffortMap,
+        warnings
+      });
+      result.reasoningConfig = {
+        type: "adaptive",
+        maxReasoningEffort: effort,
+        ...amazonBedrockOptions.reasoningConfig
+      };
+    } else {
+      const budgetTokens = mapReasoningToProviderBudget({
+        reasoning,
+        maxOutputTokens: capabilities.maxOutputTokens,
+        maxReasoningBudget: capabilities.maxOutputTokens,
+        warnings
+      });
+      if (budgetTokens != null) {
+        result.reasoningConfig = {
+          type: "enabled",
+          budgetTokens,
+          ...amazonBedrockOptions.reasoningConfig
+        };
+      }
+    }
+  } else if (reasoning !== "none") {
+    const effort = mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: amazonBedrockReasoningEffortMap,
+      warnings
+    });
+    result.reasoningConfig = {
+      maxReasoningEffort: effort,
+      ...amazonBedrockOptions.reasoningConfig
+    };
+  }
+  if (((_a = result.reasoningConfig) == null ? void 0 : _a.type) === "disabled") {
+    delete result.reasoningConfig.maxReasoningEffort;
+    delete result.reasoningConfig.budgetTokens;
+  }
+  return result;
+}
 
-// src/bedrock-embedding-model.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+// src/amazon-bedrock-embedding-model.ts
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+} from "@ai-sdk/provider-utils";
 
-// src/bedrock-embedding-options.ts
-var import_v44 = require("zod/v4");
-var amazonBedrockEmbeddingModelOptionsSchema = import_v44.z.object({
+// src/amazon-bedrock-embedding-model-options.ts
+import { z as z5 } from "zod/v4";
+var amazonBedrockEmbeddingModelOptionsSchema = z5.object({
   /**
    * The number of dimensions the resulting output embeddings should have (defaults to 1024).
    * Only supported in amazon.titan-embed-text-v2:0.
    */
-  dimensions: import_v44.z.union([import_v44.z.literal(1024), import_v44.z.literal(512), import_v44.z.literal(256)]).optional(),
+  dimensions: z5.union([z5.literal(1024), z5.literal(512), z5.literal(256)]).optional(),
   /**
    * Flag indicating whether or not to normalize the output embeddings. Defaults to true.
    * Only supported in amazon.titan-embed-text-v2:0.
    */
-  normalize: import_v44.z.boolean().optional(),
+  normalize: z5.boolean().optional(),
   /**
    * The number of dimensions for Nova embedding models (defaults to 1024).
    * Supported values: 256, 384, 1024, 3072.
    * Only supported in amazon.nova-* embedding models.
    */
-  embeddingDimension: import_v44.z.union([import_v44.z.literal(256), import_v44.z.literal(384), import_v44.z.literal(1024), import_v44.z.literal(3072)]).optional(),
+  embeddingDimension: z5.union([z5.literal(256), z5.literal(384), z5.literal(1024), z5.literal(3072)]).optional(),
   /**
    * The purpose of the embedding. Defaults to 'GENERIC_INDEX'.
    * Only supported in amazon.nova-* embedding models.
    */
-  embeddingPurpose: import_v44.z.enum([
+  embeddingPurpose: z5.enum([
     "GENERIC_INDEX",
     "TEXT_RETRIEVAL",
     "IMAGE_RETRIEVAL",
@@ -1599,22 +1815,22 @@ var amazonBedrockEmbeddingModelOptionsSchema = import_v44.z.object({
    * Common values: `search_document`, `search_query`, `classification`, `clustering`.
    * If not set, the provider defaults to `search_query`.
    */
-  inputType: import_v44.z.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
+  inputType: z5.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
   /**
    * Truncation behavior when input exceeds the model's context length.
    * Supported in Cohere and Nova embedding models. Defaults to 'END' for Nova models.
    */
-  truncate: import_v44.z.enum(["NONE", "START", "END"]).optional(),
+  truncate: z5.enum(["NONE", "START", "END"]).optional(),
   /**
    * The number of dimensions the resulting output embeddings should have (defaults to 1536).
    * Only supported in cohere.embed-v4:0 and newer Cohere embedding models.
    */
-  outputDimension: import_v44.z.union([import_v44.z.literal(256), import_v44.z.literal(512), import_v44.z.literal(1024), import_v44.z.literal(1536)]).optional()
+  outputDimension: z5.union([z5.literal(256), z5.literal(512), z5.literal(1024), z5.literal(1536)]).optional()
 });
 
-// src/bedrock-embedding-model.ts
-var import_v45 = require("zod/v4");
-var BedrockEmbeddingModel = class {
+// src/amazon-bedrock-embedding-model.ts
+import { z as z6 } from "zod/v4";
+var AmazonBedrockEmbeddingModel = class _AmazonBedrockEmbeddingModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
@@ -1623,6 +1839,15 @@ var BedrockEmbeddingModel = class {
     this.maxEmbeddingsPerCall = 1;
     this.supportsParallelCalls = true;
   }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _AmazonBedrockEmbeddingModel(options.modelId, options.config);
+  }
   getUrl(modelId) {
     const encodedModelId = encodeURIComponent(modelId);
     return `${this.config.baseUrl()}/model/${encodedModelId}/invoke`;
@@ -1633,57 +1858,64 @@ var BedrockEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider4.TooManyEmbeddingValuesForCallError({
+      throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
         values
       });
     }
-    const bedrockOptions = (_a = await (0, import_provider_utils5.parseProviderOptions)({
+    const amazonBedrockOptions = (_b = (_a = await parseProviderOptions3({
+      provider: "amazonBedrock",
+      providerOptions,
+      schema: amazonBedrockEmbeddingModelOptionsSchema
+    })) != null ? _a : await parseProviderOptions3({
       provider: "bedrock",
       providerOptions,
       schema: amazonBedrockEmbeddingModelOptionsSchema
-    })) != null ? _a : {};
+    })) != null ? _b : {};
     const isNovaModel = this.modelId.startsWith("amazon.nova-") && this.modelId.includes("embed");
-    const isCohereModel = this.modelId.startsWith("cohere.embed-");
+    const isCohereModel = this.modelId.includes("cohere.embed-");
     const args = isNovaModel ? {
       taskType: "SINGLE_EMBEDDING",
       singleEmbeddingParams: {
-        embeddingPurpose: (_b = bedrockOptions.embeddingPurpose) != null ? _b : "GENERIC_INDEX",
-        embeddingDimension: (_c = bedrockOptions.embeddingDimension) != null ? _c : 1024,
+        embeddingPurpose: (_c = amazonBedrockOptions.embeddingPurpose) != null ? _c : "GENERIC_INDEX",
+        embeddingDimension: (_d = amazonBedrockOptions.embeddingDimension) != null ? _d : 1024,
         text: {
-          truncationMode: (_d = bedrockOptions.truncate) != null ? _d : "END",
+          truncationMode: (_e = amazonBedrockOptions.truncate) != null ? _e : "END",
           value: values[0]
         }
       }
     } : isCohereModel ? {
       // Cohere embedding models on Bedrock require `input_type`.
       // Without it, the service attempts other schema branches and rejects the request.
-      input_type: (_e = bedrockOptions.inputType) != null ? _e : "search_query",
+      input_type: (_f = amazonBedrockOptions.inputType) != null ? _f : "search_query",
       texts: [values[0]],
-      truncate: bedrockOptions.truncate,
-      output_dimension: bedrockOptions.outputDimension
+      truncate: amazonBedrockOptions.truncate,
+      output_dimension: amazonBedrockOptions.outputDimension
     } : {
       inputText: values[0],
-      dimensions: bedrockOptions.dimensions,
-      normalize: bedrockOptions.normalize
+      dimensions: amazonBedrockOptions.dimensions,
+      normalize: amazonBedrockOptions.normalize
     };
     const url = this.getUrl(this.modelId);
-    const { value: response } = await (0, import_provider_utils5.postJsonToApi)({
+    const { value: response, responseHeaders } = await postJsonToApi2({
       url,
-      headers: await (0, import_provider_utils5.resolve)(
-        (0, import_provider_utils5.combineHeaders)(await (0, import_provider_utils5.resolve)(this.config.headers), headers)
+      headers: await resolve2(
+        combineHeaders2(
+          this.config.headers ? await resolve2(this.config.headers) : void 0,
+          headers
+        )
       ),
       body: args,
-      failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
-        errorSchema: BedrockErrorSchema,
+      failedResponseHandler: createJsonErrorResponseHandler2({
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
-        BedrockEmbeddingResponseSchema
+      successfulResponseHandler: createJsonResponseHandler2(
+        AmazonBedrockEmbeddingResponseSchema
       ),
       fetch: this.config.fetch,
       abortSignal
@@ -1701,7 +1933,10 @@ var BedrockEmbeddingModel = class {
     } else {
       embedding = response.embeddings.float[0];
     }
-    const tokens = "inputTextTokenCount" in response ? response.inputTextTokenCount : "inputTokenCount" in response ? (_f = response.inputTokenCount) != null ? _f : 0 : NaN;
+    const headerTokenCount = Number(
+      responseHeaders == null ? void 0 : responseHeaders["x-amzn-bedrock-input-token-count"]
+    );
+    const tokens = "inputTextTokenCount" in response ? response.inputTextTokenCount : "inputTokenCount" in response ? (_g = response.inputTokenCount) != null ? _g : 0 : headerTokenCount;
     return {
       embeddings: [embedding],
       usage: { tokens },
@@ -1709,51 +1944,70 @@ var BedrockEmbeddingModel = class {
     };
   }
 };
-var BedrockEmbeddingResponseSchema = import_v45.z.union([
+var AmazonBedrockEmbeddingResponseSchema = z6.union([
   // Titan-style response
-  import_v45.z.object({
-    embedding: import_v45.z.array(import_v45.z.number()),
-    inputTextTokenCount: import_v45.z.number()
+  z6.object({
+    embedding: z6.array(z6.number()),
+    inputTextTokenCount: z6.number()
   }),
   // Nova-style response
-  import_v45.z.object({
-    embeddings: import_v45.z.array(
-      import_v45.z.object({
-        embeddingType: import_v45.z.string(),
-        embedding: import_v45.z.array(import_v45.z.number())
+  z6.object({
+    embeddings: z6.array(
+      z6.object({
+        embeddingType: z6.string(),
+        embedding: z6.array(z6.number())
       })
     ),
-    inputTokenCount: import_v45.z.number().optional()
+    inputTokenCount: z6.number().optional()
   }),
   // Cohere v3-style response
-  import_v45.z.object({
-    embeddings: import_v45.z.array(import_v45.z.array(import_v45.z.number()))
+  z6.object({
+    embeddings: z6.array(z6.array(z6.number()))
   }),
   // Cohere v4-style response
-  import_v45.z.object({
-    embeddings: import_v45.z.object({
-      float: import_v45.z.array(import_v45.z.array(import_v45.z.number()))
+  z6.object({
+    embeddings: z6.object({
+      float: z6.array(z6.array(z6.number()))
     })
   })
 ]);
 
-// src/bedrock-image-model.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+// src/amazon-bedrock-image-model.ts
+import {
+  combineHeaders as combineHeaders3,
+  convertUint8ArrayToBase64,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve3,
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3
+} from "@ai-sdk/provider-utils";
 
-// src/bedrock-image-settings.ts
+// src/amazon-bedrock-image-settings.ts
 var modelMaxImagesPerCall = {
   "amazon.nova-canvas-v1:0": 5
 };
 
-// src/bedrock-image-model.ts
-var import_v46 = require("zod/v4");
-var BedrockImageModel = class {
+// src/amazon-bedrock-image-model.ts
+import { z as z7 } from "zod/v4";
+var AmazonBedrockImageModel = class _AmazonBedrockImageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
     this.specificationVersion = "v4";
     this.provider = "amazon-bedrock";
   }
+  static [WORKFLOW_SERIALIZE3](model) {
+    return serializeModelOptions3({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE3](options) {
+    return new _AmazonBedrockImageModel(options.modelId, options.config);
+  }
   get maxImagesPerCall() {
     var _a;
     return (_a = modelMaxImagesPerCall[this.modelId]) != null ? _a : 1;
@@ -1774,35 +2028,36 @@ var BedrockImageModel = class {
     files,
     mask
   }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    var _a, _b, _c, _d, _e, _f;
     const warnings = [];
     const [width, height] = size ? size.split("x").map(Number) : [];
     const hasFiles = files != null && files.length > 0;
+    const amazonBedrockOptions = (_a = providerOptions == null ? void 0 : providerOptions.amazonBedrock) != null ? _a : providerOptions == null ? void 0 : providerOptions.bedrock;
     const imageGenerationConfig = {
       ...width ? { width } : {},
       ...height ? { height } : {},
       ...seed ? { seed } : {},
       ...n ? { numberOfImages: n } : {},
-      ...((_a = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _a.quality) ? { quality: providerOptions.bedrock.quality } : {},
-      ...((_b = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _b.cfgScale) ? { cfgScale: providerOptions.bedrock.cfgScale } : {}
+      ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.quality) ? { quality: amazonBedrockOptions.quality } : {},
+      ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.cfgScale) ? { cfgScale: amazonBedrockOptions.cfgScale } : {}
     };
     let args;
     if (hasFiles) {
       const hasMask = (mask == null ? void 0 : mask.type) != null;
-      const hasMaskPrompt = ((_c = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _c.maskPrompt) != null;
-      const taskType = (_e = (_d = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _d.taskType) != null ? _e : hasMask || hasMaskPrompt ? "INPAINTING" : "IMAGE_VARIATION";
+      const hasMaskPrompt = (amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.maskPrompt) != null;
+      const taskType = (_b = amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.taskType) != null ? _b : hasMask || hasMaskPrompt ? "INPAINTING" : "IMAGE_VARIATION";
       const sourceImageBase64 = getBase64Data(files[0]);
       switch (taskType) {
         case "INPAINTING": {
           const inPaintingParams = {
             image: sourceImageBase64,
             ...prompt ? { text: prompt } : {},
-            ...((_f = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _f.negativeText) ? { negativeText: providerOptions.bedrock.negativeText } : {}
+            ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.negativeText) ? { negativeText: amazonBedrockOptions.negativeText } : {}
           };
           if (hasMask) {
             inPaintingParams.maskImage = getBase64Data(mask);
           } else if (hasMaskPrompt) {
-            inPaintingParams.maskPrompt = providerOptions.bedrock.maskPrompt;
+            inPaintingParams.maskPrompt = amazonBedrockOptions.maskPrompt;
           }
           args = {
             taskType: "INPAINTING",
@@ -1815,13 +2070,13 @@ var BedrockImageModel = class {
           const outPaintingParams = {
             image: sourceImageBase64,
             ...prompt ? { text: prompt } : {},
-            ...((_g = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _g.negativeText) ? { negativeText: providerOptions.bedrock.negativeText } : {},
-            ...((_h = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _h.outPaintingMode) ? { outPaintingMode: providerOptions.bedrock.outPaintingMode } : {}
+            ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.negativeText) ? { negativeText: amazonBedrockOptions.negativeText } : {},
+            ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.outPaintingMode) ? { outPaintingMode: amazonBedrockOptions.outPaintingMode } : {}
           };
           if (hasMask) {
             outPaintingParams.maskImage = getBase64Data(mask);
           } else if (hasMaskPrompt) {
-            outPaintingParams.maskPrompt = providerOptions.bedrock.maskPrompt;
+            outPaintingParams.maskPrompt = amazonBedrockOptions.maskPrompt;
           }
           args = {
             taskType: "OUTPAINTING",
@@ -1844,9 +2099,9 @@ var BedrockImageModel = class {
           const imageVariationParams = {
             images,
             ...prompt ? { text: prompt } : {},
-            ...((_i = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _i.negativeText) ? { negativeText: providerOptions.bedrock.negativeText } : {},
-            ...((_j = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _j.similarityStrength) != null ? {
-              similarityStrength: providerOptions.bedrock.similarityStrength
+            ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.negativeText) ? { negativeText: amazonBedrockOptions.negativeText } : {},
+            ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.similarityStrength) != null ? {
+              similarityStrength: amazonBedrockOptions.similarityStrength
             } : {}
           };
           args = {
@@ -1864,11 +2119,11 @@ var BedrockImageModel = class {
         taskType: "TEXT_IMAGE",
         textToImageParams: {
           text: prompt,
-          ...((_k = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _k.negativeText) ? {
-            negativeText: providerOptions.bedrock.negativeText
+          ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.negativeText) ? {
+            negativeText: amazonBedrockOptions.negativeText
           } : {},
-          ...((_l = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _l.style) ? {
-            style: providerOptions.bedrock.style
+          ...(amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.style) ? {
+            style: amazonBedrockOptions.style
           } : {}
         },
         imageGenerationConfig
@@ -1881,25 +2136,28 @@ var BedrockImageModel = class {
         details: "This model does not support aspect ratio. Use `size` instead."
       });
     }
-    const currentDate = (_o = (_n = (_m = this.config._internal) == null ? void 0 : _m.currentDate) == null ? void 0 : _n.call(_m)) != null ? _o : /* @__PURE__ */ new Date();
-    const { value: response, responseHeaders } = await (0, import_provider_utils6.postJsonToApi)({
+    const currentDate = (_e = (_d = (_c = this.config._internal) == null ? void 0 : _c.currentDate) == null ? void 0 : _d.call(_c)) != null ? _e : /* @__PURE__ */ new Date();
+    const { value: response, responseHeaders } = await postJsonToApi3({
       url: this.getUrl(this.modelId),
-      headers: await (0, import_provider_utils6.resolve)(
-        (0, import_provider_utils6.combineHeaders)(await (0, import_provider_utils6.resolve)(this.config.headers), headers)
+      headers: await resolve3(
+        combineHeaders3(
+          this.config.headers ? await resolve3(this.config.headers) : void 0,
+          headers
+        )
       ),
       body: args,
-      failedResponseHandler: (0, import_provider_utils6.createJsonErrorResponseHandler)({
-        errorSchema: BedrockErrorSchema,
+      failedResponseHandler: createJsonErrorResponseHandler3({
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
-        bedrockImageResponseSchema
+      successfulResponseHandler: createJsonResponseHandler3(
+        amazonBedrockImageResponseSchema
       ),
       abortSignal,
       fetch: this.config.fetch
     });
     if (response.status === "Request Moderated") {
-      const moderationReasons = (_p = response.details) == null ? void 0 : _p["Moderation Reasons"];
+      const moderationReasons = (_f = response.details) == null ? void 0 : _f["Moderation Reasons"];
       const reasons = Array.isArray(moderationReasons) ? moderationReasons : ["Unknown"];
       throw new Error(
         `Amazon Bedrock request was moderated: ${reasons.join(", ")}`
@@ -1928,42 +2186,48 @@ function getBase64Data(file) {
     );
   }
   if (file.data instanceof Uint8Array) {
-    return (0, import_provider_utils6.convertUint8ArrayToBase64)(file.data);
+    return convertUint8ArrayToBase64(file.data);
   }
   return file.data;
 }
-var bedrockImageResponseSchema = import_v46.z.object({
+var amazonBedrockImageResponseSchema = z7.object({
   // Normal successful response
-  images: import_v46.z.array(import_v46.z.string()).optional(),
+  images: z7.array(z7.string()).optional(),
   // Moderation response fields
-  id: import_v46.z.string().optional(),
-  status: import_v46.z.string().optional(),
-  result: import_v46.z.unknown().optional(),
-  progress: import_v46.z.unknown().optional(),
-  details: import_v46.z.record(import_v46.z.string(), import_v46.z.unknown()).optional(),
-  preview: import_v46.z.unknown().optional()
+  id: z7.string().optional(),
+  status: z7.string().optional(),
+  result: z7.unknown().optional(),
+  progress: z7.unknown().optional(),
+  details: z7.record(z7.string(), z7.unknown()).optional(),
+  preview: z7.unknown().optional()
 });
 
-// src/bedrock-sigv4-fetch.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_aws4fetch = require("aws4fetch");
+// src/amazon-bedrock-sigv4-fetch.ts
+import {
+  combineHeaders as combineHeaders4,
+  normalizeHeaders,
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent
+} from "@ai-sdk/provider-utils";
+import { AwsV4Signer } from "aws4fetch";
 
 // src/version.ts
-var VERSION = true ? "5.0.0-beta.8" : "0.0.0-test";
+var VERSION = true ? "5.0.0-beta.85" : "0.0.0-test";
 
-// src/bedrock-sigv4-fetch.ts
-function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
+// src/amazon-bedrock-sigv4-fetch.ts
+function createSigV4FetchFunction(getCredentials, fetch, service = "bedrock") {
   return async (input, init) => {
     var _a, _b;
+    const effectiveFetch = fetch != null ? fetch : globalThis.fetch;
     const request = input instanceof Request ? input : void 0;
-    const originalHeaders = (0, import_provider_utils7.combineHeaders)(
-      (0, import_provider_utils7.normalizeHeaders)(request == null ? void 0 : request.headers),
-      (0, import_provider_utils7.normalizeHeaders)(init == null ? void 0 : init.headers)
+    const originalHeaders = combineHeaders4(
+      normalizeHeaders(request == null ? void 0 : request.headers),
+      normalizeHeaders(init == null ? void 0 : init.headers)
     );
-    const headersWithUserAgent = (0, import_provider_utils7.withUserAgentSuffix)(
+    const headersWithUserAgent = withUserAgentSuffix(
       originalHeaders,
       `ai-sdk/amazon-bedrock/${VERSION}`,
-      (0, import_provider_utils7.getRuntimeEnvironmentUserAgent)()
+      getRuntimeEnvironmentUserAgent()
     );
     let effectiveBody = (_a = init == null ? void 0 : init.body) != null ? _a : void 0;
     if (effectiveBody === void 0 && request && request.body !== null) {
@@ -1974,7 +2238,7 @@ function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
     }
     const effectiveMethod = (_b = init == null ? void 0 : init.method) != null ? _b : request == null ? void 0 : request.method;
     if ((effectiveMethod == null ? void 0 : effectiveMethod.toUpperCase()) !== "POST" || !effectiveBody) {
-      return fetch(input, {
+      return effectiveFetch(input, {
         ...init,
         headers: headersWithUserAgent
       });
@@ -1982,7 +2246,7 @@ function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
     const body = prepareBodyString(effectiveBody);
     const credentials = await getCredentials();
-    const signer = new import_aws4fetch.AwsV4Signer({
+    const signer = new AwsV4Signer({
       url,
       method: "POST",
       headers: Object.entries(headersWithUserAgent),
@@ -1991,12 +2255,12 @@ function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
       accessKeyId: credentials.accessKeyId,
       secretAccessKey: credentials.secretAccessKey,
       sessionToken: credentials.sessionToken,
-      service: "bedrock"
+      service
     });
     const signingResult = await signer.sign();
-    const signedHeaders = (0, import_provider_utils7.normalizeHeaders)(signingResult.headers);
-    const combinedHeaders = (0, import_provider_utils7.combineHeaders)(headersWithUserAgent, signedHeaders);
-    return fetch(input, {
+    const signedHeaders = normalizeHeaders(signingResult.headers);
+    const combinedHeaders = combineHeaders4(headersWithUserAgent, signedHeaders);
+    return effectiveFetch(input, {
       ...init,
       body,
       headers: combinedHeaders
@@ -2014,64 +2278,72 @@ function prepareBodyString(body) {
     return JSON.stringify(body);
   }
 }
-function createApiKeyFetchFunction(apiKey, fetch = globalThis.fetch) {
+function createApiKeyFetchFunction(apiKey, fetch) {
   return async (input, init) => {
-    const originalHeaders = (0, import_provider_utils7.normalizeHeaders)(init == null ? void 0 : init.headers);
-    const headersWithUserAgent = (0, import_provider_utils7.withUserAgentSuffix)(
+    const effectiveFetch = fetch != null ? fetch : globalThis.fetch;
+    const originalHeaders = normalizeHeaders(init == null ? void 0 : init.headers);
+    const headersWithUserAgent = withUserAgentSuffix(
       originalHeaders,
       `ai-sdk/amazon-bedrock/${VERSION}`,
-      (0, import_provider_utils7.getRuntimeEnvironmentUserAgent)()
+      getRuntimeEnvironmentUserAgent()
     );
-    const finalHeaders = (0, import_provider_utils7.combineHeaders)(headersWithUserAgent, {
+    const finalHeaders = combineHeaders4(headersWithUserAgent, {
       Authorization: `Bearer ${apiKey}`
     });
-    return fetch(input, {
+    return effectiveFetch(input, {
       ...init,
       headers: finalHeaders
     });
   };
 }
 
-// src/reranking/bedrock-reranking-model.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
+// src/reranking/amazon-bedrock-reranking-model.ts
+import {
+  combineHeaders as combineHeaders5,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4
+} from "@ai-sdk/provider-utils";
 
-// src/reranking/bedrock-reranking-api.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var bedrockRerankingResponseSchema = (0, import_provider_utils8.lazySchema)(
-  () => (0, import_provider_utils8.zodSchema)(
-    import_v47.z.object({
-      results: import_v47.z.array(
-        import_v47.z.object({
-          index: import_v47.z.number(),
-          relevanceScore: import_v47.z.number()
+// src/reranking/amazon-bedrock-reranking-api.ts
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var amazonBedrockRerankingResponseSchema = lazySchema(
+  () => zodSchema(
+    z8.object({
+      results: z8.array(
+        z8.object({
+          index: z8.number(),
+          relevanceScore: z8.number()
         })
       ),
-      nextToken: import_v47.z.string().optional()
+      nextToken: z8.string().optional()
     })
   )
 );
 
-// src/reranking/bedrock-reranking-options.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
-var amazonBedrockRerankingModelOptionsSchema = (0, import_provider_utils9.lazySchema)(
-  () => (0, import_provider_utils9.zodSchema)(
-    import_v48.z.object({
+// src/reranking/amazon-bedrock-reranking-model-options.ts
+import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var amazonBedrockRerankingModelOptionsSchema = lazySchema2(
+  () => zodSchema2(
+    z9.object({
       /**
        * If the total number of results was greater than could fit in a response, a token is returned in the nextToken field. You can enter that token in this field to return the next batch of results.
        */
-      nextToken: import_v48.z.string().optional(),
+      nextToken: z9.string().optional(),
       /**
        * Additional model request fields to pass to the model.
        */
-      additionalModelRequestFields: import_v48.z.record(import_v48.z.string(), import_v48.z.any()).optional()
+      additionalModelRequestFields: z9.record(z9.string(), z9.any()).optional()
     })
   )
 );
 
-// src/reranking/bedrock-reranking-model.ts
-var BedrockRerankingModel = class {
+// src/reranking/amazon-bedrock-reranking-model.ts
+var AmazonBedrockRerankingModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
@@ -2086,7 +2358,12 @@ var BedrockRerankingModel = class {
     abortSignal,
     providerOptions
   }) {
-    const bedrockOptions = await (0, import_provider_utils10.parseProviderOptions)({
+    var _a;
+    const amazonBedrockOptions = (_a = await parseProviderOptions4({
+      provider: "amazonBedrock",
+      providerOptions,
+      schema: amazonBedrockRerankingModelOptionsSchema
+    })) != null ? _a : await parseProviderOptions4({
       provider: "bedrock",
       providerOptions,
       schema: amazonBedrockRerankingModelOptionsSchema
@@ -2095,13 +2372,13 @@ var BedrockRerankingModel = class {
       value: response,
       responseHeaders,
       rawValue
-    } = await (0, import_provider_utils10.postJsonToApi)({
+    } = await postJsonToApi4({
       url: `${this.config.baseUrl()}/rerank`,
-      headers: await (0, import_provider_utils10.resolve)(
-        (0, import_provider_utils10.combineHeaders)(await (0, import_provider_utils10.resolve)(this.config.headers), headers)
+      headers: await resolve4(
+        combineHeaders5(await resolve4(this.config.headers), headers)
       ),
       body: {
-        nextToken: bedrockOptions == null ? void 0 : bedrockOptions.nextToken,
+        nextToken: amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.nextToken,
         queries: [
           {
             textQuery: { text: query },
@@ -2109,10 +2386,10 @@ var BedrockRerankingModel = class {
           }
         ],
         rerankingConfiguration: {
-          bedrockRerankingConfiguration: {
+          amazonBedrockRerankingConfiguration: {
             modelConfiguration: {
               modelArn: `arn:aws:bedrock:${this.config.region}::foundation-model/${this.modelId}`,
-              additionalModelRequestFields: bedrockOptions == null ? void 0 : bedrockOptions.additionalModelRequestFields
+              additionalModelRequestFields: amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.additionalModelRequestFields
             },
             numberOfResults: topN
           },
@@ -2129,12 +2406,12 @@ var BedrockRerankingModel = class {
           }
         }))
       },
-      failedResponseHandler: (0, import_provider_utils10.createJsonErrorResponseHandler)({
-        errorSchema: BedrockErrorSchema,
+      failedResponseHandler: createJsonErrorResponseHandler4({
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: (0, import_provider_utils10.createJsonResponseHandler)(
-        bedrockRerankingResponseSchema
+      successfulResponseHandler: createJsonResponseHandler4(
+        amazonBedrockRerankingResponseSchema
       ),
       fetch: this.config.fetch,
       abortSignal
@@ -2149,15 +2426,15 @@ var BedrockRerankingModel = class {
   }
 };
 
-// src/bedrock-provider.ts
+// src/amazon-bedrock-provider.ts
 function createAmazonBedrock(options = {}) {
-  const rawApiKey = (0, import_provider_utils11.loadOptionalSetting)({
+  const rawApiKey = loadOptionalSetting({
     settingValue: options.apiKey,
     environmentVariableName: "AWS_BEARER_TOKEN_BEDROCK"
   });
   const apiKey = rawApiKey && rawApiKey.trim().length > 0 ? rawApiKey.trim() : void 0;
   const fetchFunction = apiKey ? createApiKeyFetchFunction(apiKey, options.fetch) : createSigV4FetchFunction(async () => {
-    const region = (0, import_provider_utils11.loadSetting)({
+    const region = loadSetting({
       settingValue: options.region,
       settingName: "region",
       environmentVariableName: "AWS_REGION",
@@ -2179,19 +2456,19 @@ function createAmazonBedrock(options = {}) {
     try {
       return {
         region,
-        accessKeyId: (0, import_provider_utils11.loadSetting)({
+        accessKeyId: loadSetting({
           settingValue: options.accessKeyId,
           settingName: "accessKeyId",
           environmentVariableName: "AWS_ACCESS_KEY_ID",
           description: "AWS access key ID"
         }),
-        secretAccessKey: (0, import_provider_utils11.loadSetting)({
+        secretAccessKey: loadSetting({
           settingValue: options.secretAccessKey,
           settingName: "secretAccessKey",
           environmentVariableName: "AWS_SECRET_ACCESS_KEY",
           description: "AWS secret access key"
         }),
-        sessionToken: (0, import_provider_utils11.loadOptionalSetting)({
+        sessionToken: options.accessKeyId != null && options.secretAccessKey != null ? options.sessionToken : loadOptionalSetting({
           settingValue: options.sessionToken,
           environmentVariableName: "AWS_SESSION_TOKEN"
         })
@@ -2220,12 +2497,12 @@ Original error: ${errorMessage}`
   const getHeaders = () => {
     var _a;
     const baseHeaders = (_a = options.headers) != null ? _a : {};
-    return (0, import_provider_utils11.withUserAgentSuffix)(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION}`);
+    return withUserAgentSuffix2(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION}`);
   };
-  const getBedrockRuntimeBaseUrl = () => {
+  const getAmazonBedrockRuntimeBaseUrl = () => {
     var _a, _b;
-    return (_b = (0, import_provider_utils11.withoutTrailingSlash)(
-      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${(0, import_provider_utils11.loadSetting)({
+    return (_b = withoutTrailingSlash(
+      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${loadSetting({
         settingValue: options.region,
         settingName: "region",
         environmentVariableName: "AWS_REGION",
@@ -2233,10 +2510,10 @@ Original error: ${errorMessage}`
       })}.amazonaws.com`
     )) != null ? _b : `https://bedrock-runtime.us-east-1.amazonaws.com`;
   };
-  const getBedrockAgentRuntimeBaseUrl = () => {
+  const getAmazonBedrockAgentRuntimeBaseUrl = () => {
     var _a, _b;
-    return (_b = (0, import_provider_utils11.withoutTrailingSlash)(
-      (_a = options.baseURL) != null ? _a : `https://bedrock-agent-runtime.${(0, import_provider_utils11.loadSetting)({
+    return (_b = withoutTrailingSlash(
+      (_a = options.baseURL) != null ? _a : `https://bedrock-agent-runtime.${loadSetting({
         settingValue: options.region,
         settingName: "region",
         environmentVariableName: "AWS_REGION",
@@ -2244,11 +2521,11 @@ Original error: ${errorMessage}`
       })}.amazonaws.com`
     )) != null ? _b : `https://bedrock-agent-runtime.us-west-2.amazonaws.com`;
   };
-  const createChatModel = (modelId) => new BedrockChatLanguageModel(modelId, {
-    baseUrl: getBedrockRuntimeBaseUrl,
+  const createChatModel = (modelId) => new AmazonBedrockChatLanguageModel(modelId, {
+    baseUrl: getAmazonBedrockRuntimeBaseUrl,
     headers: getHeaders,
     fetch: fetchFunction,
-    generateId: import_provider_utils11.generateId
+    generateId
   });
   const provider = function(modelId) {
     if (new.target) {
@@ -2258,19 +2535,19 @@ Original error: ${errorMessage}`
     }
     return createChatModel(modelId);
   };
-  const createEmbeddingModel = (modelId) => new BedrockEmbeddingModel(modelId, {
-    baseUrl: getBedrockRuntimeBaseUrl,
+  const createEmbeddingModel = (modelId) => new AmazonBedrockEmbeddingModel(modelId, {
+    baseUrl: getAmazonBedrockRuntimeBaseUrl,
     headers: getHeaders,
     fetch: fetchFunction
   });
-  const createImageModel = (modelId) => new BedrockImageModel(modelId, {
-    baseUrl: getBedrockRuntimeBaseUrl,
+  const createImageModel = (modelId) => new AmazonBedrockImageModel(modelId, {
+    baseUrl: getAmazonBedrockRuntimeBaseUrl,
     headers: getHeaders,
     fetch: fetchFunction
   });
-  const createRerankingModel = (modelId) => new BedrockRerankingModel(modelId, {
-    baseUrl: getBedrockAgentRuntimeBaseUrl,
-    region: (0, import_provider_utils11.loadSetting)({
+  const createRerankingModel = (modelId) => new AmazonBedrockRerankingModel(modelId, {
+    baseUrl: getAmazonBedrockAgentRuntimeBaseUrl,
+    region: loadSetting({
       settingValue: options.region,
       settingName: "region",
       environmentVariableName: "AWS_REGION",
@@ -2289,14 +2566,14 @@ Original error: ${errorMessage}`
   provider.imageModel = createImageModel;
   provider.reranking = createRerankingModel;
   provider.rerankingModel = createRerankingModel;
-  provider.tools = import_internal2.anthropicTools;
+  provider.tools = anthropicTools2;
   return provider;
 }
-var bedrock = createAmazonBedrock();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+var amazonBedrock = createAmazonBedrock();
+export {
   VERSION,
-  bedrock,
+  amazonBedrock,
+  amazonBedrock as bedrock,
   createAmazonBedrock
-});
+};
 //# sourceMappingURL=index.js.map