@ai-sdk/amazon-bedrock 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/index.js

@@ -1,38 +1,30 @@
-"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");
+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");
+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 z3 } from "zod/v4";
 
 // src/bedrock-api-types.ts
 var BEDROCK_STOP_REASONS = [
@@ -66,57 +58,71 @@ var BEDROCK_DOCUMENT_MIME_TYPES = {
 };
 
 // src/bedrock-chat-options.ts
-var import_v4 = require("zod/v4");
-var bedrockFilePartProviderOptions = import_v4.z.object({
+import { z } from "zod/v4";
+var bedrockFilePartProviderOptions = 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 amazonBedrockLanguageModelOptions = 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", "max"]).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()
+import { z as z2 } from "zod/v4";
+var BedrockErrorSchema = 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");
+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");
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { toUtf8, fromUtf8 } from "@smithy/util-utf8";
 function createBedrockEventStreamDecoder(body, processEvent) {
-  const codec = new import_eventstream_codec.EventStreamCodec(import_util_utf8.toUtf8, import_util_utf8.fromUtf8);
+  const codec = new EventStreamCodec(toUtf8, fromUtf8);
   let buffer = new Uint8Array(0);
   const textDecoder = new TextDecoder();
   return body.pipeThrough(
@@ -155,9 +161,9 @@ function createBedrockEventStreamDecoder(body, processEvent) {
 
 // src/bedrock-event-stream-response-handler.ts
 var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response }) => {
-  const responseHeaders = (0, import_provider_utils.extractResponseHeaders)(response);
+  const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new import_provider.EmptyResponseBodyError({});
+    throw new EmptyResponseBodyError({});
   }
   return {
     responseHeaders,
@@ -165,7 +171,7 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
       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 +180,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
           });
@@ -194,9 +200,14 @@ 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");
+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,
@@ -243,7 +254,7 @@ async function prepareTools({
       toolChoice: preparedAnthropicToolChoice,
       toolWarnings: anthropicToolWarnings,
       betas: anthropicBetas
-    } = await (0, import_internal.prepareTools)({
+    } = await prepareAnthropicTools({
       tools: ProviderTools,
       toolChoice,
       supportsStructuredOutput: false,
@@ -257,7 +268,7 @@ 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;
       });
@@ -267,7 +278,7 @@ async function prepareTools({
           toolSpec: {
             name: tool.name,
             inputSchema: {
-              json: await (0, import_provider_utils2.asSchema)(fullToolDefinition.inputSchema).jsonSchema
+              json: await asSchema(fullToolDefinition.inputSchema).jsonSchema
             }
           }
         });
@@ -312,7 +323,7 @@ async function prepareTools({
         break;
       default: {
         const _exhaustiveCheck = type;
-        throw new import_provider2.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError({
           functionality: `tool choice type: ${_exhaustiveCheck}`
         });
       }
@@ -367,8 +378,15 @@ 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");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  isProviderReference,
+  parseProviderOptions,
+  stripFileExtension
+} from "@ai-sdk/provider-utils";
 
 // src/normalize-tool-call-id.ts
 function isMistralModel(modelId) {
@@ -393,7 +411,7 @@ function getCachePoint(providerMetadata) {
 }
 async function shouldEnableCitations(providerMetadata) {
   var _a, _b;
-  const bedrockOptions = await (0, import_provider_utils3.parseProviderOptions)({
+  const bedrockOptions = await parseProviderOptions({
     provider: "bedrock",
     providerOptions: providerMetadata,
     schema: bedrockFilePartProviderOptions
@@ -414,7 +432,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"
           });
         }
@@ -443,8 +461,13 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                     break;
                   }
                   case "file": {
+                    if (isProviderReference(part.data)) {
+                      throw new UnsupportedFunctionalityError2({
+                        functionality: "file parts with provider references"
+                      });
+                    }
                     if (part.data instanceof URL) {
-                      throw new import_provider3.UnsupportedFunctionalityError({
+                      throw new UnsupportedFunctionalityError2({
                         functionality: "File URL data"
                       });
                     }
@@ -452,12 +475,12 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                       bedrockContent.push({
                         image: {
                           format: getBedrockImageFormat(part.mediaType),
-                          source: { bytes: (0, import_provider_utils3.convertToBase64)(part.data) }
+                          source: { bytes: convertToBase64(part.data) }
                         }
                       });
                     } else {
                       if (!part.mediaType) {
-                        throw new import_provider3.UnsupportedFunctionalityError({
+                        throw new UnsupportedFunctionalityError2({
                           functionality: "file without mime type",
                           message: "File mime type is required in user message part content"
                         });
@@ -468,8 +491,8 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                       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) },
+                          name: part.filename ? stripFileExtension(part.filename) : generateDocumentName(),
+                          source: { bytes: convertToBase64(part.data) },
                           ...enableCitations && {
                             citations: { enabled: true }
                           }
@@ -495,9 +518,9 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                       switch (contentPart.type) {
                         case "text":
                           return { text: contentPart.text };
-                        case "image-data":
+                        case "file-data":
                           if (!contentPart.mediaType.startsWith("image/")) {
-                            throw new import_provider3.UnsupportedFunctionalityError({
+                            throw new UnsupportedFunctionalityError2({
                               functionality: `media type: ${contentPart.mediaType}`
                             });
                           }
@@ -511,7 +534,7 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                             }
                           };
                         default: {
-                          throw new import_provider3.UnsupportedFunctionalityError({
+                          throw new UnsupportedFunctionalityError2({
                             functionality: `unsupported tool content part type: ${contentPart.type}`
                           });
                         }
@@ -564,12 +587,15 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
           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({
@@ -588,38 +614,41 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                 break;
               }
               case "reasoning": {
-                const reasoningMetadata = await (0, import_provider_utils3.parseProviderOptions)({
+                const reasoningMetadata = await parseProviderOptions({
                   provider: "bedrock",
                   providerOptions: part.providerOptions,
                   schema: bedrockReasoningMetadataSchema
                 });
-                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) {
+                  bedrockContent.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) {
+                  bedrockContent.push({
+                    reasoningContent: {
+                      redactedReasoning: {
+                        data: reasoningMetadata.redactedData
                       }
-                    });
-                  }
+                    }
+                  });
+                } else {
+                  bedrockContent.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: trimIfLast(
+                          isLastBlock,
+                          isLastMessage,
+                          isLastContentPart,
+                          part.text
+                        )
+                      }
+                    }
+                  });
                 }
                 break;
               }
@@ -653,14 +682,14 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
 }
 function getBedrockImageFormat(mimeType) {
   if (!mimeType) {
-    throw new import_provider3.UnsupportedFunctionalityError({
+    throw new UnsupportedFunctionalityError2({
       functionality: "image without mime type",
       message: "Image mime type is required in user message part content"
     });
   }
   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(", ")}`
     });
@@ -670,7 +699,7 @@ function getBedrockImageFormat(mimeType) {
 function getBedrockDocumentFormat(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(", ")}`
     });
@@ -746,7 +775,7 @@ function mapBedrockFinishReason(finishReason, isJsonResponseFromTool) {
 }
 
 // src/bedrock-chat-language-model.ts
-var BedrockChatLanguageModel = class {
+var BedrockChatLanguageModel = class _BedrockChatLanguageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
@@ -756,6 +785,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 _BedrockChatLanguageModel(options.modelId, options.config);
+  }
   async getArgs({
     prompt,
     maxOutputTokens,
@@ -769,10 +807,11 @@ 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)({
+    let bedrockOptions = (_a = await parseProviderOptions2({
       provider: "bedrock",
       providerOptions,
       schema: amazonBedrockLanguageModelOptions
@@ -819,8 +858,17 @@ var BedrockChatLanguageModel = class {
       });
     }
     const isAnthropicModel = this.modelId.includes("anthropic");
+    const isOpenAIModel = this.modelId.startsWith("openai.");
+    bedrockOptions = resolveBedrockReasoningConfig({
+      reasoning,
+      bedrockOptions,
+      warnings,
+      isAnthropicModel,
+      modelId: this.modelId
+    });
     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 { 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",
@@ -896,7 +944,6 @@ var BedrockChatLanguageModel = class {
       }
     }
     const maxReasoningEffort = (_h = bedrockOptions.reasoningConfig) == null ? void 0 : _h.maxReasoningEffort;
-    const isOpenAIModel = this.modelId.startsWith("openai.");
     if (maxReasoningEffort != null) {
       if (isAnthropicModel) {
         bedrockOptions.additionalModelRequestFields = {
@@ -992,6 +1039,7 @@ var BedrockChatLanguageModel = class {
     const {
       reasoningConfig: _,
       additionalModelRequestFields: __,
+      serviceTier: ___,
       ...filteredBedrockOptions
     } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
     const additionalModelResponseFieldPaths = isAnthropicModel ? ["/delta/stop_sequence"] : void 0;
@@ -1006,6 +1054,11 @@ var BedrockChatLanguageModel = class {
         ...Object.keys(inferenceConfig).length > 0 && {
           inferenceConfig
         },
+        ...bedrockOptions.serviceTier != null && {
+          serviceTier: {
+            type: bedrockOptions.serviceTier
+          }
+        },
         ...filteredBedrockOptions,
         ...toolConfig.tools !== void 0 && toolConfig.tools.length > 0 ? { toolConfig } : {}
       },
@@ -1017,7 +1070,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,18 +1083,18 @@ 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)({
+      failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => {
           var _a2;
           return `${(_a2 = error.message) != null ? _a2 : "Unknown error"}`;
         }
       }),
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         BedrockResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -1047,7 +1103,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) {
@@ -1149,11 +1205,11 @@ 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)({
+      failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
@@ -1444,146 +1500,214 @@ 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 BedrockStopReasonSchema = z3.union([
+  z3.enum(BEDROCK_STOP_REASONS),
+  z3.string()
 ]);
-var BedrockAdditionalModelResponseFieldsSchema = import_v43.z.object({
-  delta: import_v43.z.object({
-    stop_sequence: import_v43.z.string().nullish()
+var BedrockAdditionalModelResponseFieldsSchema = z3.object({
+  delta: z3.object({
+    stop_sequence: z3.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(z3.unknown());
+var BedrockToolUseSchema = z3.object({
+  toolUseId: z3.string(),
+  name: z3.string(),
+  input: z3.unknown()
 });
-var BedrockReasoningTextSchema = import_v43.z.object({
-  signature: import_v43.z.string().nullish(),
-  text: import_v43.z.string()
+var BedrockReasoningTextSchema = z3.object({
+  signature: z3.string().nullish(),
+  text: z3.string()
 });
-var BedrockRedactedReasoningSchema = import_v43.z.object({
-  data: import_v43.z.string()
+var BedrockRedactedReasoningSchema = z3.object({
+  data: z3.string()
 });
-var BedrockResponseSchema = import_v43.z.object({
-  metrics: import_v43.z.object({
-    latencyMs: import_v43.z.number()
+var BedrockResponseSchema = z3.object({
+  metrics: z3.object({
+    latencyMs: z3.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(),
+  output: z3.object({
+    message: z3.object({
+      content: z3.array(
+        z3.object({
+          text: z3.string().nullish(),
           toolUse: BedrockToolUseSchema.nullish(),
-          reasoningContent: import_v43.z.union([
-            import_v43.z.object({
+          reasoningContent: z3.union([
+            z3.object({
               reasoningText: BedrockReasoningTextSchema
             }),
-            import_v43.z.object({
+            z3.object({
               redactedReasoning: BedrockRedactedReasoningSchema
             })
           ]).nullish()
         })
       ),
-      role: import_v43.z.string()
+      role: z3.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()
+  trace: z3.unknown().nullish(),
+  performanceConfig: z3.object({ latency: z3.string() }).nullish(),
+  serviceTier: z3.object({ type: z3.string() }).nullish(),
+  usage: z3.object({
+    inputTokens: z3.number(),
+    outputTokens: z3.number(),
+    totalTokens: z3.number(),
+    cacheReadInputTokens: z3.number().nullish(),
+    cacheWriteInputTokens: z3.number().nullish(),
+    cacheDetails: z3.array(z3.object({ inputTokens: z3.number(), ttl: z3.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 BedrockStreamSchema = z3.object({
+  contentBlockDelta: z3.object({
+    contentBlockIndex: z3.number(),
+    delta: z3.union([
+      z3.object({ text: z3.string() }),
+      z3.object({ toolUse: z3.object({ input: z3.string() }) }),
+      z3.object({
+        reasoningContent: z3.object({ text: z3.string() })
       }),
-      import_v43.z.object({
-        reasoningContent: import_v43.z.object({
-          signature: import_v43.z.string()
+      z3.object({
+        reasoningContent: z3.object({
+          signature: z3.string()
         })
       }),
-      import_v43.z.object({
-        reasoningContent: import_v43.z.object({ data: import_v43.z.string() })
+      z3.object({
+        reasoningContent: z3.object({ data: z3.string() })
       })
     ]).nullish()
   }).nullish(),
-  contentBlockStart: import_v43.z.object({
-    contentBlockIndex: import_v43.z.number(),
-    start: import_v43.z.object({
+  contentBlockStart: z3.object({
+    contentBlockIndex: z3.number(),
+    start: z3.object({
       toolUse: BedrockToolUseSchema.nullish()
     }).nullish()
   }).nullish(),
-  contentBlockStop: import_v43.z.object({
-    contentBlockIndex: import_v43.z.number()
+  contentBlockStop: z3.object({
+    contentBlockIndex: z3.number()
   }).nullish(),
-  internalServerException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
-  messageStop: import_v43.z.object({
+  internalServerException: z3.record(z3.string(), z3.unknown()).nullish(),
+  messageStop: z3.object({
     additionalModelResponseFields: BedrockAdditionalModelResponseFieldsSchema.nullish(),
     stopReason: BedrockStopReasonSchema
   }).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: z3.object({
+    trace: z3.unknown().nullish(),
+    performanceConfig: z3.object({ latency: z3.string() }).nullish(),
+    serviceTier: z3.object({ type: z3.string() }).nullish(),
+    usage: z3.object({
+      cacheReadInputTokens: z3.number().nullish(),
+      cacheWriteInputTokens: z3.number().nullish(),
+      cacheDetails: z3.array(z3.object({ inputTokens: z3.number(), ttl: z3.string() })).nullish(),
+      inputTokens: z3.number(),
+      outputTokens: z3.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()
+  modelStreamErrorException: z3.record(z3.string(), z3.unknown()).nullish(),
+  throttlingException: z3.record(z3.string(), z3.unknown()).nullish(),
+  validationException: z3.record(z3.string(), z3.unknown()).nullish()
 });
-var bedrockReasoningMetadataSchema = import_v43.z.object({
-  signature: import_v43.z.string().optional(),
-  redactedData: import_v43.z.string().optional()
+var bedrockReasoningMetadataSchema = z3.object({
+  signature: z3.string().optional(),
+  redactedData: z3.string().optional()
 });
+var bedrockReasoningEffortMap = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max"
+};
+function resolveBedrockReasoningConfig({
+  reasoning,
+  bedrockOptions,
+  warnings,
+  isAnthropicModel,
+  modelId
+}) {
+  if (!isCustomReasoning(reasoning) || bedrockOptions.reasoningConfig != null) {
+    return bedrockOptions;
+  }
+  const result = { ...bedrockOptions };
+  if (isAnthropicModel) {
+    const capabilities = getModelCapabilities(modelId);
+    if (reasoning === "none") {
+      result.reasoningConfig = { type: "disabled" };
+    } else if (capabilities.supportsAdaptiveThinking) {
+      const effort = mapReasoningToProviderEffort({
+        reasoning,
+        effortMap: bedrockReasoningEffortMap,
+        warnings
+      });
+      result.reasoningConfig = {
+        type: "adaptive",
+        maxReasoningEffort: effort
+      };
+    } else {
+      const budgetTokens = mapReasoningToProviderBudget({
+        reasoning,
+        maxOutputTokens: capabilities.maxOutputTokens,
+        maxReasoningBudget: capabilities.maxOutputTokens,
+        warnings
+      });
+      if (budgetTokens != null) {
+        result.reasoningConfig = {
+          type: "enabled",
+          budgetTokens
+        };
+      }
+    }
+  } else if (reasoning !== "none") {
+    const effort = mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: bedrockReasoningEffortMap,
+      warnings
+    });
+    result.reasoningConfig = { maxReasoningEffort: effort };
+  }
+  return result;
+}
 
 // src/bedrock-embedding-model.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+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({
+import { z as z4 } from "zod/v4";
+var amazonBedrockEmbeddingModelOptionsSchema = z4.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: z4.union([z4.literal(1024), z4.literal(512), z4.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: z4.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: z4.union([z4.literal(256), z4.literal(384), z4.literal(1024), z4.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: z4.enum([
     "GENERIC_INDEX",
     "TEXT_RETRIEVAL",
     "IMAGE_RETRIEVAL",
@@ -1599,22 +1723,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: z4.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: z4.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: z4.union([z4.literal(256), z4.literal(512), z4.literal(1024), z4.literal(1536)]).optional()
 });
 
 // src/bedrock-embedding-model.ts
-var import_v45 = require("zod/v4");
-var BedrockEmbeddingModel = class {
+import { z as z5 } from "zod/v4";
+var BedrockEmbeddingModel = class _BedrockEmbeddingModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
@@ -1623,6 +1747,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 _BedrockEmbeddingModel(options.modelId, options.config);
+  }
   getUrl(modelId) {
     const encodedModelId = encodeURIComponent(modelId);
     return `${this.config.baseUrl()}/model/${encodedModelId}/invoke`;
@@ -1635,14 +1768,14 @@ var BedrockEmbeddingModel = class {
   }) {
     var _a, _b, _c, _d, _e, _f;
     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 bedrockOptions = (_a = await parseProviderOptions3({
       provider: "bedrock",
       providerOptions,
       schema: amazonBedrockEmbeddingModelOptionsSchema
@@ -1672,17 +1805,20 @@ var BedrockEmbeddingModel = class {
       normalize: bedrockOptions.normalize
     };
     const url = this.getUrl(this.modelId);
-    const { value: response } = await (0, import_provider_utils5.postJsonToApi)({
+    const { value: response } = 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)({
+      failedResponseHandler: createJsonErrorResponseHandler2({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         BedrockEmbeddingResponseSchema
       ),
       fetch: this.config.fetch,
@@ -1709,36 +1845,46 @@ var BedrockEmbeddingModel = class {
     };
   }
 };
-var BedrockEmbeddingResponseSchema = import_v45.z.union([
+var BedrockEmbeddingResponseSchema = z5.union([
   // Titan-style response
-  import_v45.z.object({
-    embedding: import_v45.z.array(import_v45.z.number()),
-    inputTextTokenCount: import_v45.z.number()
+  z5.object({
+    embedding: z5.array(z5.number()),
+    inputTextTokenCount: z5.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())
+  z5.object({
+    embeddings: z5.array(
+      z5.object({
+        embeddingType: z5.string(),
+        embedding: z5.array(z5.number())
       })
     ),
-    inputTokenCount: import_v45.z.number().optional()
+    inputTokenCount: z5.number().optional()
   }),
   // Cohere v3-style response
-  import_v45.z.object({
-    embeddings: import_v45.z.array(import_v45.z.array(import_v45.z.number()))
+  z5.object({
+    embeddings: z5.array(z5.array(z5.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()))
+  z5.object({
+    embeddings: z5.object({
+      float: z5.array(z5.array(z5.number()))
     })
   })
 ]);
 
 // src/bedrock-image-model.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+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
 var modelMaxImagesPerCall = {
@@ -1746,14 +1892,23 @@ var modelMaxImagesPerCall = {
 };
 
 // src/bedrock-image-model.ts
-var import_v46 = require("zod/v4");
-var BedrockImageModel = class {
+import { z as z6 } from "zod/v4";
+var BedrockImageModel = class _BedrockImageModel {
   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 _BedrockImageModel(options.modelId, options.config);
+  }
   get maxImagesPerCall() {
     var _a;
     return (_a = modelMaxImagesPerCall[this.modelId]) != null ? _a : 1;
@@ -1882,17 +2037,20 @@ var BedrockImageModel = class {
       });
     }
     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 { 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)({
+      failedResponseHandler: createJsonErrorResponseHandler3({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         bedrockImageResponseSchema
       ),
       abortSignal,
@@ -1928,42 +2086,47 @@ 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 bedrockImageResponseSchema = z6.object({
   // Normal successful response
-  images: import_v46.z.array(import_v46.z.string()).optional(),
+  images: z6.array(z6.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: z6.string().optional(),
+  status: z6.string().optional(),
+  result: z6.unknown().optional(),
+  progress: z6.unknown().optional(),
+  details: z6.record(z6.string(), z6.unknown()).optional(),
+  preview: z6.unknown().optional()
 });
 
 // src/bedrock-sigv4-fetch.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_aws4fetch = require("aws4fetch");
+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.4" : "0.0.0-test";
+var VERSION = true ? "5.0.0-beta.40" : "0.0.0-test";
 
 // src/bedrock-sigv4-fetch.ts
 function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
   return async (input, init) => {
     var _a, _b;
     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) {
@@ -1982,7 +2145,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),
@@ -1994,8 +2157,8 @@ function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
       service: "bedrock"
     });
     const signingResult = await signer.sign();
-    const signedHeaders = (0, import_provider_utils7.normalizeHeaders)(signingResult.headers);
-    const combinedHeaders = (0, import_provider_utils7.combineHeaders)(headersWithUserAgent, signedHeaders);
+    const signedHeaders = normalizeHeaders(signingResult.headers);
+    const combinedHeaders = combineHeaders4(headersWithUserAgent, signedHeaders);
     return fetch(input, {
       ...init,
       body,
@@ -2016,13 +2179,13 @@ function prepareBodyString(body) {
 }
 function createApiKeyFetchFunction(apiKey, fetch = globalThis.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 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, {
@@ -2033,39 +2196,46 @@ function createApiKeyFetchFunction(apiKey, fetch = globalThis.fetch) {
 }
 
 // src/reranking/bedrock-reranking-model.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
+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()
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var bedrockRerankingResponseSchema = lazySchema(
+  () => zodSchema(
+    z7.object({
+      results: z7.array(
+        z7.object({
+          index: z7.number(),
+          relevanceScore: z7.number()
         })
       ),
-      nextToken: import_v47.z.string().optional()
+      nextToken: z7.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({
+import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var amazonBedrockRerankingModelOptionsSchema = lazySchema2(
+  () => zodSchema2(
+    z8.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: z8.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: z8.record(z8.string(), z8.any()).optional()
     })
   )
 );
@@ -2086,7 +2256,7 @@ var BedrockRerankingModel = class {
     abortSignal,
     providerOptions
   }) {
-    const bedrockOptions = await (0, import_provider_utils10.parseProviderOptions)({
+    const bedrockOptions = await parseProviderOptions4({
       provider: "bedrock",
       providerOptions,
       schema: amazonBedrockRerankingModelOptionsSchema
@@ -2095,10 +2265,10 @@ 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,
@@ -2129,11 +2299,11 @@ var BedrockRerankingModel = class {
           }
         }))
       },
-      failedResponseHandler: (0, import_provider_utils10.createJsonErrorResponseHandler)({
+      failedResponseHandler: createJsonErrorResponseHandler4({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: (0, import_provider_utils10.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler4(
         bedrockRerankingResponseSchema
       ),
       fetch: this.config.fetch,
@@ -2151,13 +2321,13 @@ var BedrockRerankingModel = class {
 
 // src/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 +2349,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: loadOptionalSetting({
           settingValue: options.sessionToken,
           environmentVariableName: "AWS_SESSION_TOKEN"
         })
@@ -2220,12 +2390,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 = () => {
     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",
@@ -2235,8 +2405,8 @@ Original error: ${errorMessage}`
   };
   const getBedrockAgentRuntimeBaseUrl = () => {
     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",
@@ -2248,7 +2418,7 @@ Original error: ${errorMessage}`
     baseUrl: getBedrockRuntimeBaseUrl,
     headers: getHeaders,
     fetch: fetchFunction,
-    generateId: import_provider_utils11.generateId
+    generateId
   });
   const provider = function(modelId) {
     if (new.target) {
@@ -2270,7 +2440,7 @@ Original error: ${errorMessage}`
   });
   const createRerankingModel = (modelId) => new BedrockRerankingModel(modelId, {
     baseUrl: getBedrockAgentRuntimeBaseUrl,
-    region: (0, import_provider_utils11.loadSetting)({
+    region: loadSetting({
       settingValue: options.region,
       settingName: "region",
       environmentVariableName: "AWS_REGION",
@@ -2289,14 +2459,13 @@ 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 = {
+export {
   VERSION,
   bedrock,
   createAmazonBedrock
-});
+};
 //# sourceMappingURL=index.js.map