@ai-sdk/amazon-bedrock 2.2.10 → 3.0.0-alpha.10

package/dist/index.js

@@ -29,9 +29,8 @@ module.exports = __toCommonJS(src_exports);
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
 
 // src/bedrock-chat-language-model.ts
-var import_provider4 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/bedrock-api-types.ts
 var BEDROCK_CACHE_POINT = {
@@ -50,11 +49,26 @@ var BEDROCK_STOP_REASONS = [
   "tool_use"
 ];
 
-// src/bedrock-error.ts
+// src/bedrock-chat-options.ts
 var import_zod = require("zod");
-var BedrockErrorSchema = import_zod.z.object({
-  message: import_zod.z.string(),
-  type: import_zod.z.string().nullish()
+var bedrockProviderOptions = import_zod.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_zod.z.record(import_zod.z.any()).optional(),
+  reasoningConfig: import_zod.z.object({
+    type: import_zod.z.union([import_zod.z.literal("enabled"), import_zod.z.literal("disabled")]).optional(),
+    budgetTokens: import_zod.z.number().optional()
+  }).optional()
+});
+
+// src/bedrock-error.ts
+var import_zod2 = require("zod");
+var BedrockErrorSchema = import_zod2.z.object({
+  message: import_zod2.z.string(),
+  type: import_zod2.z.string().nullish()
 });
 
 // src/bedrock-event-stream-response-handler.ts
@@ -74,7 +88,7 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
     responseHeaders,
     value: response.body.pipeThrough(
       new TransformStream({
-        transform(chunk, controller) {
+        async transform(chunk, controller) {
           var _a, _b;
           const newBuffer = new Uint8Array(buffer.length + chunk.length);
           newBuffer.set(buffer);
@@ -95,7 +109,7 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
               buffer = buffer.slice(totalLength);
               if (((_a = decoded.headers[":message-type"]) == null ? void 0 : _a.value) === "event") {
                 const data = textDecoder.decode(decoded.body);
-                const parsedDataResult = (0, import_provider_utils.safeParseJSON)({ text: data });
+                const parsedDataResult = await (0, import_provider_utils.safeParseJSON)({ text: data });
                 if (!parsedDataResult.success) {
                   controller.enqueue(parsedDataResult);
                   break;
@@ -104,7 +118,7 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
                 let wrappedData = {
                   [(_b = decoded.headers[":event-type"]) == null ? void 0 : _b.value]: parsedDataResult.value
                 };
-                const validatedWrappedData = (0, import_provider_utils.safeValidateTypes)({
+                const validatedWrappedData = await (0, import_provider_utils.safeValidateTypes)({
                   value: wrappedData,
                   schema: chunkSchema
                 });
@@ -130,9 +144,11 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
 
 // src/bedrock-prepare-tools.ts
 var import_provider2 = require("@ai-sdk/provider");
-function prepareTools(mode) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   if (tools == null) {
     return {
       toolConfig: { tools: void 0, toolChoice: void 0 },
@@ -156,7 +172,6 @@ function prepareTools(mode) {
       });
     }
   }
-  const toolChoice = mode.toolChoice;
   if (toolChoice == null) {
     return {
       toolConfig: { tools: bedrockTools, toolChoice: void 0 },
@@ -191,7 +206,7 @@ function prepareTools(mode) {
     default: {
       const _exhaustiveCheck = type;
       throw new import_provider2.UnsupportedFunctionalityError({
-        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+        functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
@@ -205,8 +220,8 @@ function getCachePoint(providerMetadata) {
   var _a;
   return (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.cachePoint;
 }
-function convertToBedrockChatMessages(prompt) {
-  var _a, _b, _c, _d, _e;
+async function convertToBedrockChatMessages(prompt) {
+  var _a, _b, _c, _d;
   const blocks = groupIntoBlocks(prompt);
   let system = [];
   const messages = [];
@@ -223,7 +238,7 @@ function convertToBedrockChatMessages(prompt) {
         }
         for (const message of block.messages) {
           system.push({ text: message.content });
-          if (getCachePoint(message.providerMetadata)) {
+          if (getCachePoint(message.providerOptions)) {
             system.push(BEDROCK_CACHE_POINT);
           }
         }
@@ -232,7 +247,7 @@ function convertToBedrockChatMessages(prompt) {
       case "user": {
         const bedrockContent = [];
         for (const message of block.messages) {
-          const { role, content, providerMetadata } = message;
+          const { role, content, providerOptions } = message;
           switch (role) {
             case "user": {
               for (let j = 0; j < content.length; j++) {
@@ -244,43 +259,31 @@ function convertToBedrockChatMessages(prompt) {
                     });
                     break;
                   }
-                  case "image": {
-                    if (part.image instanceof URL) {
-                      throw new import_provider3.UnsupportedFunctionalityError({
-                        functionality: "Image URLs in user messages"
-                      });
-                    }
-                    bedrockContent.push({
-                      image: {
-                        format: (_b = (_a = part.mimeType) == null ? void 0 : _a.split(
-                          "/"
-                        )) == null ? void 0 : _b[1],
-                        source: {
-                          bytes: (0, import_provider_utils2.convertUint8ArrayToBase64)(
-                            (_c = part.image) != null ? _c : part.image
-                          )
-                        }
-                      }
-                    });
-                    break;
-                  }
                   case "file": {
                     if (part.data instanceof URL) {
                       throw new import_provider3.UnsupportedFunctionalityError({
-                        functionality: "File URLs in user messages"
+                        functionality: "File URL data"
                       });
                     }
-                    bedrockContent.push({
-                      document: {
-                        format: (_e = (_d = part.mimeType) == null ? void 0 : _d.split(
-                          "/"
-                        )) == null ? void 0 : _e[1],
-                        name: generateFileId(),
-                        source: {
-                          bytes: part.data
+                    if (part.mediaType.startsWith("image/")) {
+                      const bedrockImageFormat = part.mediaType === "image/*" ? void 0 : (_b = (_a = part.mediaType) == null ? void 0 : _a.split("/")) == null ? void 0 : _b[1];
+                      bedrockContent.push({
+                        image: {
+                          format: bedrockImageFormat,
+                          source: { bytes: (0, import_provider_utils2.convertToBase64)(part.data) }
                         }
-                      }
-                    });
+                      });
+                    } else {
+                      bedrockContent.push({
+                        document: {
+                          format: (_d = (_c = part.mediaType) == null ? void 0 : _c.split(
+                            "/"
+                          )) == null ? void 0 : _d[1],
+                          name: generateFileId(),
+                          source: { bytes: (0, import_provider_utils2.convertToBase64)(part.data) }
+                        }
+                      });
+                    }
                     break;
                   }
                 }
@@ -297,12 +300,12 @@ function convertToBedrockChatMessages(prompt) {
                         text: part2.text
                       };
                     case "image":
-                      if (!part2.mimeType) {
+                      if (!part2.mediaType) {
                         throw new Error(
                           "Image mime type is required in tool result part content"
                         );
                       }
-                      const format = part2.mimeType.split("/")[1];
+                      const format = part2.mediaType.split("/")[1];
                       if (!isBedrockImageFormat(format)) {
                         throw new Error(
                           `Unsupported image format: ${format}`
@@ -332,7 +335,7 @@ function convertToBedrockChatMessages(prompt) {
               throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
             }
           }
-          if (getCachePoint(providerMetadata)) {
+          if (getCachePoint(providerOptions)) {
             bedrockContent.push(BEDROCK_CACHE_POINT);
           }
         }
@@ -366,32 +369,39 @@ function convertToBedrockChatMessages(prompt) {
                 break;
               }
               case "reasoning": {
-                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: part.signature
-                    }
-                  }
+                const reasoningMetadata = await (0, import_provider_utils2.parseProviderOptions)({
+                  provider: "bedrock",
+                  providerOptions: part.providerOptions,
+                  schema: bedrockReasoningMetadataSchema
                 });
-                break;
-              }
-              case "redacted-reasoning": {
-                bedrockContent.push({
-                  reasoningContent: {
-                    redactedReasoning: {
-                      data: part.data
-                    }
+                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
+                        }
+                      }
+                    });
+                  } else if (reasoningMetadata.redactedData != null) {
+                    bedrockContent.push({
+                      reasoningContent: {
+                        redactedReasoning: {
+                          data: reasoningMetadata.redactedData
+                        }
+                      }
+                    });
                   }
-                });
+                }
                 break;
               }
               case "tool-call": {
@@ -406,7 +416,7 @@ function convertToBedrockChatMessages(prompt) {
               }
             }
           }
-          if (getCachePoint(message.providerMetadata)) {
+          if (getCachePoint(message.providerOptions)) {
             bedrockContent.push(BEDROCK_CACHE_POINT);
           }
         }
@@ -494,19 +504,18 @@ function mapBedrockFinishReason(finishReason) {
 
 // src/bedrock-chat-language-model.ts
 var BedrockChatLanguageModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
     this.provider = "amazon-bedrock";
-    this.defaultObjectGenerationMode = "tool";
-    this.supportsImageUrls = false;
+    this.supportedUrls = {
+      // no supported urls for bedrock
+    };
   }
-  getArgs({
-    mode,
+  async getArgs({
     prompt,
-    maxTokens,
+    maxOutputTokens,
     temperature,
     topP,
     topK,
@@ -515,10 +524,16 @@ var BedrockChatLanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
-    providerMetadata
+    tools,
+    toolChoice,
+    providerOptions
   }) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const type = mode.type;
+    var _a, _b, _c, _d, _e;
+    const bedrockOptions = (_a = await (0, import_provider_utils3.parseProviderOptions)({
+      provider: "bedrock",
+      providerOptions,
+      schema: bedrockProviderOptions
+    })) != null ? _a : {};
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({
@@ -551,35 +566,25 @@ var BedrockChatLanguageModel = class {
         details: "JSON response format is not supported."
       });
     }
-    const { system, messages } = convertToBedrockChatMessages(prompt);
-    const reasoningConfigOptions = BedrockReasoningConfigOptionsSchema.safeParse(
-      (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.reasoning_config
-    );
-    if (!reasoningConfigOptions.success) {
-      throw new import_provider4.InvalidArgumentError({
-        argument: "providerOptions.bedrock.reasoning_config",
-        message: "invalid reasoning configuration options",
-        cause: reasoningConfigOptions.error
-      });
-    }
-    const isThinking = ((_b = reasoningConfigOptions.data) == null ? void 0 : _b.type) === "enabled";
-    const thinkingBudget = (_e = (_c = reasoningConfigOptions.data) == null ? void 0 : _c.budgetTokens) != null ? _e : (_d = reasoningConfigOptions.data) == null ? void 0 : _d.budget_tokens;
+    const { system, messages } = await convertToBedrockChatMessages(prompt);
+    const isThinking = ((_b = bedrockOptions.reasoningConfig) == null ? void 0 : _b.type) === "enabled";
+    const thinkingBudget = (_c = bedrockOptions.reasoningConfig) == null ? void 0 : _c.budgetTokens;
     const inferenceConfig = {
-      ...maxTokens != null && { maxTokens },
+      ...maxOutputTokens != null && { maxOutputTokens },
       ...temperature != null && { temperature },
       ...topP != null && { topP },
       ...stopSequences != null && { stopSequences }
     };
     if (isThinking && thinkingBudget != null) {
-      if (inferenceConfig.maxTokens != null) {
-        inferenceConfig.maxTokens += thinkingBudget;
+      if (inferenceConfig.maxOutputTokens != null) {
+        inferenceConfig.maxOutputTokens += thinkingBudget;
       } else {
-        inferenceConfig.maxTokens = thinkingBudget + 4096;
+        inferenceConfig.maxOutputTokens = thinkingBudget + 4096;
       }
-      this.settings.additionalModelRequestFields = {
-        ...this.settings.additionalModelRequestFields,
-        reasoning_config: {
-          type: (_f = reasoningConfigOptions.data) == null ? void 0 : _f.type,
+      bedrockOptions.additionalModelRequestFields = {
+        ...bedrockOptions.additionalModelRequestFields,
+        reasoningConfig: {
+          type: (_d = bedrockOptions.reasoningConfig) == null ? void 0 : _d.type,
           budget_tokens: thinkingBudget
         }
       };
@@ -600,62 +605,24 @@ var BedrockChatLanguageModel = class {
         details: "topP is not supported when thinking is enabled"
       });
     }
-    const baseArgs = {
-      system,
-      additionalModelRequestFields: this.settings.additionalModelRequestFields,
-      ...Object.keys(inferenceConfig).length > 0 && {
-        inferenceConfig
+    const { toolConfig, toolWarnings } = prepareTools({ tools, toolChoice });
+    return {
+      command: {
+        system,
+        messages,
+        additionalModelRequestFields: bedrockOptions.additionalModelRequestFields,
+        ...Object.keys(inferenceConfig).length > 0 && {
+          inferenceConfig
+        },
+        ...providerOptions == null ? void 0 : providerOptions.bedrock,
+        ...((_e = toolConfig.tools) == null ? void 0 : _e.length) ? { toolConfig } : {}
       },
-      messages,
-      ...providerMetadata == null ? void 0 : providerMetadata.bedrock
+      warnings: [...warnings, ...toolWarnings]
     };
-    switch (type) {
-      case "regular": {
-        const { toolConfig, toolWarnings } = prepareTools(mode);
-        return {
-          command: {
-            ...baseArgs,
-            ...((_g = toolConfig.tools) == null ? void 0 : _g.length) ? { toolConfig } : {}
-          },
-          warnings: [...warnings, ...toolWarnings]
-        };
-      }
-      case "object-json": {
-        throw new import_provider4.UnsupportedFunctionalityError({
-          functionality: "json-mode object generation"
-        });
-      }
-      case "object-tool": {
-        return {
-          command: {
-            ...baseArgs,
-            toolConfig: {
-              tools: [
-                {
-                  toolSpec: {
-                    name: mode.tool.name,
-                    description: mode.tool.description,
-                    inputSchema: {
-                      json: mode.tool.parameters
-                    }
-                  }
-                }
-              ],
-              toolChoice: { tool: { name: mode.tool.name } }
-            }
-          },
-          warnings
-        };
-      }
-      default: {
-        const _exhaustiveCheck = type;
-        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
-      }
-    }
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
-    const { command: args, warnings } = this.getArgs(options);
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    const { command: args, warnings } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse`;
     const { value: response, responseHeaders } = await (0, import_provider_utils3.postJsonToApi)({
       url,
@@ -677,67 +644,78 @@ var BedrockChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages: rawPrompt, ...rawSettings } = args;
+    const content = [];
+    for (const part of response.output.message.content) {
+      if (part.text) {
+        content.push({ type: "text", text: part.text });
+      }
+      if (part.reasoningContent) {
+        if ("reasoningText" in part.reasoningContent) {
+          const reasoning = {
+            type: "reasoning",
+            text: part.reasoningContent.reasoningText.text
+          };
+          if (part.reasoningContent.reasoningText.signature) {
+            reasoning.providerMetadata = {
+              bedrock: {
+                signature: part.reasoningContent.reasoningText.signature
+              }
+            };
+          }
+          content.push(reasoning);
+        } else if ("redactedReasoning" in part.reasoningContent) {
+          content.push({
+            type: "reasoning",
+            text: "",
+            providerMetadata: {
+              bedrock: {
+                redactedData: (_a = part.reasoningContent.redactedReasoning.data) != null ? _a : ""
+              }
+            }
+          });
+        }
+      }
+      if (part.toolUse) {
+        content.push({
+          type: "tool-call",
+          toolCallType: "function",
+          toolCallId: (_c = (_b = part.toolUse) == null ? void 0 : _b.toolUseId) != null ? _c : this.config.generateId(),
+          toolName: (_e = (_d = part.toolUse) == null ? void 0 : _d.name) != null ? _e : `tool-${this.config.generateId()}`,
+          args: JSON.stringify((_g = (_f = part.toolUse) == null ? void 0 : _f.input) != null ? _g : "")
+        });
+      }
+    }
     const providerMetadata = response.trace || response.usage ? {
       bedrock: {
         ...response.trace && typeof response.trace === "object" ? { trace: response.trace } : {},
-        ...response.usage && {
+        ...((_h = response.usage) == null ? void 0 : _h.cacheWriteInputTokens) != null && {
           usage: {
-            cacheReadInputTokens: (_b = (_a = response.usage) == null ? void 0 : _a.cacheReadInputTokens) != null ? _b : Number.NaN,
-            cacheWriteInputTokens: (_d = (_c = response.usage) == null ? void 0 : _c.cacheWriteInputTokens) != null ? _d : Number.NaN
+            cacheWriteInputTokens: response.usage.cacheWriteInputTokens
           }
         }
       }
     } : void 0;
-    const reasoning = response.output.message.content.filter((content) => content.reasoningContent).map((content) => {
-      var _a2;
-      if (content.reasoningContent && "reasoningText" in content.reasoningContent) {
-        return {
-          type: "text",
-          text: content.reasoningContent.reasoningText.text,
-          ...content.reasoningContent.reasoningText.signature && {
-            signature: content.reasoningContent.reasoningText.signature
-          }
-        };
-      } else if (content.reasoningContent && "redactedReasoning" in content.reasoningContent) {
-        return {
-          type: "redacted",
-          data: (_a2 = content.reasoningContent.redactedReasoning.data) != null ? _a2 : ""
-        };
-      } else {
-        return void 0;
-      }
-    }).filter((item) => item !== void 0);
     return {
-      text: (_h = (_g = (_f = (_e = response.output) == null ? void 0 : _e.message) == null ? void 0 : _f.content) == null ? void 0 : _g.map((part) => {
-        var _a2;
-        return (_a2 = part.text) != null ? _a2 : "";
-      }).join("")) != null ? _h : void 0,
-      toolCalls: (_l = (_k = (_j = (_i = response.output) == null ? void 0 : _i.message) == null ? void 0 : _j.content) == null ? void 0 : _k.filter((part) => !!part.toolUse)) == null ? void 0 : _l.map((part) => {
-        var _a2, _b2, _c2, _d2, _e2, _f2;
-        return {
-          toolCallType: "function",
-          toolCallId: (_b2 = (_a2 = part.toolUse) == null ? void 0 : _a2.toolUseId) != null ? _b2 : this.config.generateId(),
-          toolName: (_d2 = (_c2 = part.toolUse) == null ? void 0 : _c2.name) != null ? _d2 : `tool-${this.config.generateId()}`,
-          args: JSON.stringify((_f2 = (_e2 = part.toolUse) == null ? void 0 : _e2.input) != null ? _f2 : "")
-        };
-      }),
+      content,
       finishReason: mapBedrockFinishReason(
         response.stopReason
       ),
       usage: {
-        promptTokens: (_n = (_m = response.usage) == null ? void 0 : _m.inputTokens) != null ? _n : Number.NaN,
-        completionTokens: (_p = (_o = response.usage) == null ? void 0 : _o.outputTokens) != null ? _p : Number.NaN
+        inputTokens: (_i = response.usage) == null ? void 0 : _i.inputTokens,
+        outputTokens: (_j = response.usage) == null ? void 0 : _j.outputTokens,
+        totalTokens: ((_k = response.usage) == null ? void 0 : _k.inputTokens) + ((_l = response.usage) == null ? void 0 : _l.outputTokens),
+        cachedInputTokens: (_n = (_m = response.usage) == null ? void 0 : _m.cacheReadInputTokens) != null ? _n : void 0
+      },
+      response: {
+        // TODO add id, timestamp, etc
+        headers: responseHeaders
       },
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
       warnings,
-      reasoning: reasoning.length > 0 ? reasoning : void 0,
       ...providerMetadata && { providerMetadata }
     };
   }
   async doStream(options) {
-    const { command: args, warnings } = this.getArgs(options);
+    const { command: args, warnings } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse-stream`;
     const { value: response, responseHeaders } = await (0, import_provider_utils3.postJsonToApi)({
       url,
@@ -754,19 +732,22 @@ var BedrockChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages: rawPrompt, ...rawSettings } = args;
     let finishReason = "unknown";
-    let usage = {
-      promptTokens: Number.NaN,
-      completionTokens: Number.NaN
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let providerMetadata = void 0;
     const toolCallContentBlocks = {};
     return {
       stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
             function enqueueError(bedrockError) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: bedrockError });
@@ -798,14 +779,13 @@ var BedrockChatLanguageModel = class {
               );
             }
             if (value.metadata) {
-              usage = {
-                promptTokens: (_b = (_a = value.metadata.usage) == null ? void 0 : _a.inputTokens) != null ? _b : Number.NaN,
-                completionTokens: (_d = (_c = value.metadata.usage) == null ? void 0 : _c.outputTokens) != null ? _d : Number.NaN
-              };
-              const cacheUsage = ((_e = value.metadata.usage) == null ? void 0 : _e.cacheReadInputTokens) != null || ((_f = value.metadata.usage) == null ? void 0 : _f.cacheWriteInputTokens) != null ? {
+              usage.inputTokens = (_b = (_a = value.metadata.usage) == null ? void 0 : _a.inputTokens) != null ? _b : usage.inputTokens;
+              usage.outputTokens = (_d = (_c = value.metadata.usage) == null ? void 0 : _c.outputTokens) != null ? _d : usage.outputTokens;
+              usage.totalTokens = ((_e = usage.inputTokens) != null ? _e : 0) + ((_f = usage.outputTokens) != null ? _f : 0);
+              usage.cachedInputTokens = (_h = (_g = value.metadata.usage) == null ? void 0 : _g.cacheReadInputTokens) != null ? _h : usage.cachedInputTokens;
+              const cacheUsage = ((_i = value.metadata.usage) == null ? void 0 : _i.cacheWriteInputTokens) != null ? {
                 usage: {
-                  cacheReadInputTokens: (_h = (_g = value.metadata.usage) == null ? void 0 : _g.cacheReadInputTokens) != null ? _h : Number.NaN,
-                  cacheWriteInputTokens: (_j = (_i = value.metadata.usage) == null ? void 0 : _i.cacheWriteInputTokens) != null ? _j : Number.NaN
+                  cacheWriteInputTokens: value.metadata.usage.cacheWriteInputTokens
                 }
               } : void 0;
               const trace = value.metadata.trace ? {
@@ -820,33 +800,45 @@ var BedrockChatLanguageModel = class {
                 };
               }
             }
-            if (((_k = value.contentBlockDelta) == null ? void 0 : _k.delta) && "text" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.text) {
+            if (((_j = value.contentBlockDelta) == null ? void 0 : _j.delta) && "text" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.text) {
               controller.enqueue({
-                type: "text-delta",
-                textDelta: value.contentBlockDelta.delta.text
+                type: "text",
+                text: value.contentBlockDelta.delta.text
               });
             }
-            if (((_l = value.contentBlockDelta) == null ? void 0 : _l.delta) && "reasoningContent" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.reasoningContent) {
+            if (((_k = value.contentBlockDelta) == null ? void 0 : _k.delta) && "reasoningContent" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.reasoningContent) {
               const reasoningContent = value.contentBlockDelta.delta.reasoningContent;
               if ("text" in reasoningContent && reasoningContent.text) {
                 controller.enqueue({
                   type: "reasoning",
-                  textDelta: reasoningContent.text
+                  text: reasoningContent.text
                 });
               } else if ("signature" in reasoningContent && reasoningContent.signature) {
                 controller.enqueue({
-                  type: "reasoning-signature",
-                  signature: reasoningContent.signature
+                  type: "reasoning",
+                  text: "",
+                  providerMetadata: {
+                    bedrock: {
+                      signature: reasoningContent.signature
+                    }
+                  }
                 });
+                controller.enqueue({ type: "reasoning-part-finish" });
               } else if ("data" in reasoningContent && reasoningContent.data) {
                 controller.enqueue({
-                  type: "redacted-reasoning",
-                  data: reasoningContent.data
+                  type: "reasoning",
+                  text: "",
+                  providerMetadata: {
+                    bedrock: {
+                      redactedData: reasoningContent.data
+                    }
+                  }
                 });
+                controller.enqueue({ type: "reasoning-part-finish" });
               }
             }
             const contentBlockStart = value.contentBlockStart;
-            if (((_m = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _m.toolUse) != null) {
+            if (((_l = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _l.toolUse) != null) {
               const toolUse = contentBlockStart.start.toolUse;
               toolCallContentBlocks[contentBlockStart.contentBlockIndex] = {
                 toolCallId: toolUse.toolUseId,
@@ -857,7 +849,7 @@ var BedrockChatLanguageModel = class {
             const contentBlockDelta = value.contentBlockDelta;
             if ((contentBlockDelta == null ? void 0 : contentBlockDelta.delta) && "toolUse" in contentBlockDelta.delta && contentBlockDelta.delta.toolUse) {
               const contentBlock = toolCallContentBlocks[contentBlockDelta.contentBlockIndex];
-              const delta = (_n = contentBlockDelta.delta.toolUse.input) != null ? _n : "";
+              const delta = (_m = contentBlockDelta.delta.toolUse.input) != null ? _m : "";
               controller.enqueue({
                 type: "tool-call-delta",
                 toolCallType: "function",
@@ -893,9 +885,8 @@ var BedrockChatLanguageModel = class {
           }
         })
       ),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings
+      // TODO request?
+      response: { headers: responseHeaders }
     };
   }
   getUrl(modelId) {
@@ -903,118 +894,134 @@ var BedrockChatLanguageModel = class {
     return `${this.config.baseUrl()}/model/${encodedModelId}`;
   }
 };
-var BedrockReasoningConfigOptionsSchema = import_zod2.z.object({
-  type: import_zod2.z.union([import_zod2.z.literal("enabled"), import_zod2.z.literal("disabled")]).nullish(),
-  budget_tokens: import_zod2.z.number().nullish(),
-  budgetTokens: import_zod2.z.number().nullish()
-}).nullish();
-var BedrockStopReasonSchema = import_zod2.z.union([
-  import_zod2.z.enum(BEDROCK_STOP_REASONS),
-  import_zod2.z.string()
+var BedrockStopReasonSchema = import_zod3.z.union([
+  import_zod3.z.enum(BEDROCK_STOP_REASONS),
+  import_zod3.z.string()
 ]);
-var BedrockToolUseSchema = import_zod2.z.object({
-  toolUseId: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  input: import_zod2.z.unknown()
+var BedrockToolUseSchema = import_zod3.z.object({
+  toolUseId: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  input: import_zod3.z.unknown()
 });
-var BedrockReasoningTextSchema = import_zod2.z.object({
-  signature: import_zod2.z.string().nullish(),
-  text: import_zod2.z.string()
+var BedrockReasoningTextSchema = import_zod3.z.object({
+  signature: import_zod3.z.string().nullish(),
+  text: import_zod3.z.string()
 });
-var BedrockRedactedReasoningSchema = import_zod2.z.object({
-  data: import_zod2.z.string()
+var BedrockRedactedReasoningSchema = import_zod3.z.object({
+  data: import_zod3.z.string()
 });
-var BedrockResponseSchema = import_zod2.z.object({
-  metrics: import_zod2.z.object({
-    latencyMs: import_zod2.z.number()
+var BedrockResponseSchema = import_zod3.z.object({
+  metrics: import_zod3.z.object({
+    latencyMs: import_zod3.z.number()
   }).nullish(),
-  output: import_zod2.z.object({
-    message: import_zod2.z.object({
-      content: import_zod2.z.array(
-        import_zod2.z.object({
-          text: import_zod2.z.string().nullish(),
+  output: import_zod3.z.object({
+    message: import_zod3.z.object({
+      content: import_zod3.z.array(
+        import_zod3.z.object({
+          text: import_zod3.z.string().nullish(),
           toolUse: BedrockToolUseSchema.nullish(),
-          reasoningContent: import_zod2.z.union([
-            import_zod2.z.object({
+          reasoningContent: import_zod3.z.union([
+            import_zod3.z.object({
               reasoningText: BedrockReasoningTextSchema
             }),
-            import_zod2.z.object({
+            import_zod3.z.object({
               redactedReasoning: BedrockRedactedReasoningSchema
             })
           ]).nullish()
         })
       ),
-      role: import_zod2.z.string()
+      role: import_zod3.z.string()
     })
   }),
   stopReason: BedrockStopReasonSchema,
-  trace: import_zod2.z.unknown().nullish(),
-  usage: import_zod2.z.object({
-    inputTokens: import_zod2.z.number(),
-    outputTokens: import_zod2.z.number(),
-    totalTokens: import_zod2.z.number(),
-    cacheReadInputTokens: import_zod2.z.number().nullish(),
-    cacheWriteInputTokens: import_zod2.z.number().nullish()
+  trace: import_zod3.z.unknown().nullish(),
+  usage: import_zod3.z.object({
+    inputTokens: import_zod3.z.number(),
+    outputTokens: import_zod3.z.number(),
+    totalTokens: import_zod3.z.number(),
+    cacheReadInputTokens: import_zod3.z.number().nullish(),
+    cacheWriteInputTokens: import_zod3.z.number().nullish()
   })
 });
-var BedrockStreamSchema = import_zod2.z.object({
-  contentBlockDelta: import_zod2.z.object({
-    contentBlockIndex: import_zod2.z.number(),
-    delta: import_zod2.z.union([
-      import_zod2.z.object({ text: import_zod2.z.string() }),
-      import_zod2.z.object({ toolUse: import_zod2.z.object({ input: import_zod2.z.string() }) }),
-      import_zod2.z.object({
-        reasoningContent: import_zod2.z.object({ text: import_zod2.z.string() })
+var BedrockStreamSchema = import_zod3.z.object({
+  contentBlockDelta: import_zod3.z.object({
+    contentBlockIndex: import_zod3.z.number(),
+    delta: import_zod3.z.union([
+      import_zod3.z.object({ text: import_zod3.z.string() }),
+      import_zod3.z.object({ toolUse: import_zod3.z.object({ input: import_zod3.z.string() }) }),
+      import_zod3.z.object({
+        reasoningContent: import_zod3.z.object({ text: import_zod3.z.string() })
       }),
-      import_zod2.z.object({
-        reasoningContent: import_zod2.z.object({
-          signature: import_zod2.z.string()
+      import_zod3.z.object({
+        reasoningContent: import_zod3.z.object({
+          signature: import_zod3.z.string()
         })
       }),
-      import_zod2.z.object({
-        reasoningContent: import_zod2.z.object({ data: import_zod2.z.string() })
+      import_zod3.z.object({
+        reasoningContent: import_zod3.z.object({ data: import_zod3.z.string() })
       })
     ]).nullish()
   }).nullish(),
-  contentBlockStart: import_zod2.z.object({
-    contentBlockIndex: import_zod2.z.number(),
-    start: import_zod2.z.object({
+  contentBlockStart: import_zod3.z.object({
+    contentBlockIndex: import_zod3.z.number(),
+    start: import_zod3.z.object({
       toolUse: BedrockToolUseSchema.nullish()
     }).nullish()
   }).nullish(),
-  contentBlockStop: import_zod2.z.object({
-    contentBlockIndex: import_zod2.z.number()
+  contentBlockStop: import_zod3.z.object({
+    contentBlockIndex: import_zod3.z.number()
   }).nullish(),
-  internalServerException: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
-  messageStop: import_zod2.z.object({
-    additionalModelResponseFields: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
+  internalServerException: import_zod3.z.record(import_zod3.z.unknown()).nullish(),
+  messageStop: import_zod3.z.object({
+    additionalModelResponseFields: import_zod3.z.record(import_zod3.z.unknown()).nullish(),
     stopReason: BedrockStopReasonSchema
   }).nullish(),
-  metadata: import_zod2.z.object({
-    trace: import_zod2.z.unknown().nullish(),
-    usage: import_zod2.z.object({
-      cacheReadInputTokens: import_zod2.z.number().nullish(),
-      cacheWriteInputTokens: import_zod2.z.number().nullish(),
-      inputTokens: import_zod2.z.number(),
-      outputTokens: import_zod2.z.number()
+  metadata: import_zod3.z.object({
+    trace: import_zod3.z.unknown().nullish(),
+    usage: import_zod3.z.object({
+      cacheReadInputTokens: import_zod3.z.number().nullish(),
+      cacheWriteInputTokens: import_zod3.z.number().nullish(),
+      inputTokens: import_zod3.z.number(),
+      outputTokens: import_zod3.z.number()
     }).nullish()
   }).nullish(),
-  modelStreamErrorException: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
-  throttlingException: import_zod2.z.record(import_zod2.z.unknown()).nullish(),
-  validationException: import_zod2.z.record(import_zod2.z.unknown()).nullish()
+  modelStreamErrorException: import_zod3.z.record(import_zod3.z.unknown()).nullish(),
+  throttlingException: import_zod3.z.record(import_zod3.z.unknown()).nullish(),
+  validationException: import_zod3.z.record(import_zod3.z.unknown()).nullish()
+});
+var bedrockReasoningMetadataSchema = import_zod3.z.object({
+  signature: import_zod3.z.string().optional(),
+  redactedData: import_zod3.z.string().optional()
 });
 
 // src/bedrock-embedding-model.ts
+var import_provider4 = require("@ai-sdk/provider");
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+
+// src/bedrock-embedding-options.ts
+var import_zod4 = require("zod");
+var bedrockEmbeddingProviderOptions = import_zod4.z.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_zod4.z.union([import_zod4.z.literal(1024), import_zod4.z.literal(512), import_zod4.z.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_zod4.z.boolean().optional()
+});
+
+// src/bedrock-embedding-model.ts
+var import_zod5 = require("zod");
 var BedrockEmbeddingModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
     this.provider = "amazon-bedrock";
-    this.maxEmbeddingsPerCall = void 0;
+    this.maxEmbeddingsPerCall = 1;
     this.supportsParallelCalls = true;
   }
   getUrl(modelId) {
@@ -1024,50 +1031,54 @@ var BedrockEmbeddingModel = class {
   async doEmbed({
     values,
     headers,
-    abortSignal
+    abortSignal,
+    providerOptions
   }) {
-    const embedSingleText = async (inputText) => {
-      const args = {
-        inputText,
-        dimensions: this.settings.dimensions,
-        normalize: this.settings.normalize
-      };
-      const url = this.getUrl(this.modelId);
-      const { value: response } = await (0, import_provider_utils4.postJsonToApi)({
-        url,
-        headers: await (0, import_provider_utils4.resolve)(
-          (0, import_provider_utils4.combineHeaders)(await (0, import_provider_utils4.resolve)(this.config.headers), headers)
-        ),
-        body: args,
-        failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
-          errorSchema: BedrockErrorSchema,
-          errorToMessage: (error) => `${error.type}: ${error.message}`
-        }),
-        successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
-          BedrockEmbeddingResponseSchema
-        ),
-        fetch: this.config.fetch,
-        abortSignal
+    var _a;
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new import_provider4.TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
       });
-      return {
-        embedding: response.embedding,
-        inputTextTokenCount: response.inputTextTokenCount
-      };
+    }
+    const bedrockOptions = (_a = await (0, import_provider_utils4.parseProviderOptions)({
+      provider: "bedrock",
+      providerOptions,
+      schema: bedrockEmbeddingProviderOptions
+    })) != null ? _a : {};
+    const args = {
+      inputText: values[0],
+      dimensions: bedrockOptions.dimensions,
+      normalize: bedrockOptions.normalize
+    };
+    const url = this.getUrl(this.modelId);
+    const { value: response } = await (0, import_provider_utils4.postJsonToApi)({
+      url,
+      headers: await (0, import_provider_utils4.resolve)(
+        (0, import_provider_utils4.combineHeaders)(await (0, import_provider_utils4.resolve)(this.config.headers), headers)
+      ),
+      body: args,
+      failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
+        errorSchema: BedrockErrorSchema,
+        errorToMessage: (error) => `${error.type}: ${error.message}`
+      }),
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+        BedrockEmbeddingResponseSchema
+      ),
+      fetch: this.config.fetch,
+      abortSignal
+    });
+    return {
+      embeddings: [response.embedding],
+      usage: { tokens: response.inputTextTokenCount }
     };
-    const responses = await Promise.all(values.map(embedSingleText));
-    return responses.reduce(
-      (accumulated, response) => {
-        accumulated.embeddings.push(response.embedding);
-        accumulated.usage.tokens += response.inputTextTokenCount;
-        return accumulated;
-      },
-      { embeddings: [], usage: { tokens: 0 } }
-    );
   }
 };
-var BedrockEmbeddingResponseSchema = import_zod3.z.object({
-  embedding: import_zod3.z.array(import_zod3.z.number()),
-  inputTextTokenCount: import_zod3.z.number()
+var BedrockEmbeddingResponseSchema = import_zod5.z.object({
+  embedding: import_zod5.z.array(import_zod5.z.number()),
+  inputTextTokenCount: import_zod5.z.number()
 });
 
 // src/bedrock-image-model.ts
@@ -1079,18 +1090,17 @@ var modelMaxImagesPerCall = {
 };
 
 // src/bedrock-image-model.ts
-var import_zod4 = require("zod");
+var import_zod6 = require("zod");
 var BedrockImageModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
     this.provider = "amazon-bedrock";
   }
   get maxImagesPerCall() {
-    var _a, _b;
-    return (_b = (_a = this.settings.maxImagesPerCall) != null ? _a : modelMaxImagesPerCall[this.modelId]) != null ? _b : 1;
+    var _a;
+    return (_a = modelMaxImagesPerCall[this.modelId]) != null ? _a : 1;
   }
   getUrl(modelId) {
     const encodedModelId = encodeURIComponent(modelId);
@@ -1161,8 +1171,8 @@ var BedrockImageModel = class {
     };
   }
 };
-var bedrockImageResponseSchema = import_zod4.z.object({
-  images: import_zod4.z.array(import_zod4.z.string())
+var bedrockImageResponseSchema = import_zod6.z.object({
+  images: import_zod6.z.array(import_zod6.z.string())
 });
 
 // src/headers-utils.ts
@@ -1184,11 +1194,7 @@ function extractHeaders(headers) {
   return originalHeaders;
 }
 function convertHeadersToRecord(headers) {
-  const record = {};
-  headers.forEach((value, key) => {
-    record[key.toLowerCase()] = value;
-  });
-  return record;
+  return Object.fromEntries([...headers]);
 }
 
 // src/bedrock-sigv4-fetch.ts
@@ -1284,34 +1290,34 @@ function createAmazonBedrock(options = {}) {
       })}.amazonaws.com`
     )) != null ? _b : `https://bedrock-runtime.us-east-1.amazonaws.com`;
   };
-  const createChatModel = (modelId, settings = {}) => {
+  const createChatModel = (modelId) => {
     var _a;
-    return new BedrockChatLanguageModel(modelId, settings, {
+    return new BedrockChatLanguageModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
       fetch: sigv4Fetch,
       generateId: import_provider_utils7.generateId
     });
   };
-  const provider = function(modelId, settings) {
+  const provider = function(modelId) {
     if (new.target) {
       throw new Error(
         "The Amazon Bedrock model function cannot be called with the new keyword."
       );
     }
-    return createChatModel(modelId, settings);
+    return createChatModel(modelId);
   };
-  const createEmbeddingModel = (modelId, settings = {}) => {
+  const createEmbeddingModel = (modelId) => {
     var _a;
-    return new BedrockEmbeddingModel(modelId, settings, {
+    return new BedrockEmbeddingModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
       fetch: sigv4Fetch
     });
   };
-  const createImageModel = (modelId, settings = {}) => {
+  const createImageModel = (modelId) => {
     var _a;
-    return new BedrockImageModel(modelId, settings, {
+    return new BedrockImageModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
       fetch: sigv4Fetch