@ai-sdk/amazon-bedrock 3.1.0-beta.9 → 4.0.0-beta.100

package/dist/index.js

@@ -26,14 +26,9 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/bedrock-provider.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-
-// src/version.ts
-var VERSION = true ? "3.1.0-beta.9" : "0.0.0-test";
-
 // src/bedrock-provider.ts
 var import_internal2 = require("@ai-sdk/anthropic/internal");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // src/bedrock-chat-language-model.ts
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
@@ -75,6 +70,18 @@ var BEDROCK_DOCUMENT_MIME_TYPES = {
 
 // src/bedrock-chat-options.ts
 var import_v4 = require("zod/v4");
+var bedrockFilePartProviderOptions = import_v4.z.object({
+  /**
+   * Citation configuration for this document.
+   * When enabled, this document will generate citations in the response.
+   */
+  citations: import_v4.z.object({
+    /**
+     * Enable citations for this document
+     */
+    enabled: import_v4.z.boolean()
+  }).optional()
+});
 var bedrockProviderOptions = import_v4.z.object({
   /**
    * Additional inference parameters that the model supports,
@@ -84,8 +91,13 @@ var bedrockProviderOptions = import_v4.z.object({
   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")]).optional(),
-    budgetTokens: import_v4.z.number().optional()
-  }).optional()
+    budgetTokens: import_v4.z.number().optional(),
+    maxReasoningEffort: import_v4.z.enum(["low", "medium", "high"]).optional()
+  }).optional(),
+  /**
+   * Anthropic beta features to enable
+   */
+  anthropicBeta: import_v4.z.array(import_v4.z.string()).optional()
 });
 
 // src/bedrock-error.ts
@@ -95,6 +107,45 @@ var BedrockErrorSchema = import_v42.z.object({
   type: import_v42.z.string().nullish()
 });
 
+// src/convert-bedrock-usage.ts
+function convertBedrockUsage(usage) {
+  var _a, _b;
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0
+    };
+  }
+  const inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  const cacheReadTokens = (_a = usage.cacheReadInputTokens) != null ? _a : 0;
+  const cacheWriteTokens = (_b = usage.cacheWriteInputTokens) != null ? _b : 0;
+  return {
+    inputTokens: {
+      total: inputTokens,
+      noCache: inputTokens - cacheReadTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: cacheWriteTokens
+    },
+    outputTokens: {
+      total: outputTokens,
+      text: outputTokens,
+      reasoning: void 0
+    },
+    raw: usage
+  };
+}
+
 // src/bedrock-event-stream-response-handler.ts
 var import_provider = require("@ai-sdk/provider");
 var import_provider_utils = require("@ai-sdk/provider-utils");
@@ -170,11 +221,12 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
 var import_provider2 = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_internal = require("@ai-sdk/anthropic/internal");
-function prepareTools({
+async function prepareTools({
   tools,
   toolChoice,
   modelId
 }) {
+  var _a;
   const toolWarnings = [];
   const betas = /* @__PURE__ */ new Set();
   if (tools == null || tools.length === 0) {
@@ -186,10 +238,10 @@ function prepareTools({
     };
   }
   const supportedTools = tools.filter((tool) => {
-    if (tool.type === "provider-defined" && tool.id === "anthropic.web_search_20250305") {
+    if (tool.type === "provider" && tool.id === "anthropic.web_search_20250305") {
       toolWarnings.push({
-        type: "unsupported-tool",
-        tool,
+        type: "unsupported",
+        feature: "web_search_20250305 tool",
         details: "The web_search_20250305 tool is not supported on Amazon Bedrock."
       });
       return false;
@@ -205,18 +257,16 @@ function prepareTools({
     };
   }
   const isAnthropicModel = modelId.includes("anthropic.");
-  const providerDefinedTools = supportedTools.filter(
-    (t) => t.type === "provider-defined"
-  );
+  const ProviderTools = supportedTools.filter((t) => t.type === "provider");
   const functionTools = supportedTools.filter((t) => t.type === "function");
   let additionalTools = void 0;
   const bedrockTools = [];
-  const usingAnthropicTools = isAnthropicModel && providerDefinedTools.length > 0;
+  const usingAnthropicTools = isAnthropicModel && ProviderTools.length > 0;
   if (usingAnthropicTools) {
     if (functionTools.length > 0) {
       toolWarnings.push({
-        type: "unsupported-setting",
-        setting: "tools",
+        type: "unsupported",
+        feature: "mixing Anthropic provider-defined tools and standard function tools",
         details: "Mixed Anthropic provider-defined tools and standard function tools are not supported in a single call to Bedrock. Only Anthropic tools will be used."
       });
     }
@@ -224,9 +274,10 @@ function prepareTools({
       toolChoice: preparedAnthropicToolChoice,
       toolWarnings: anthropicToolWarnings,
       betas: anthropicBetas
-    } = (0, import_internal.prepareTools)({
-      tools: providerDefinedTools,
-      toolChoice
+    } = await (0, import_internal.prepareTools)({
+      tools: ProviderTools,
+      toolChoice,
+      supportsStructuredOutput: false
     });
     toolWarnings.push(...anthropicToolWarnings);
     anthropicBetas.forEach((beta) => betas.add(beta));
@@ -235,7 +286,7 @@ function prepareTools({
         tool_choice: preparedAnthropicToolChoice
       };
     }
-    for (const tool of providerDefinedTools) {
+    for (const tool of ProviderTools) {
       const toolFactory = Object.values(import_internal.anthropicTools).find((factory) => {
         const instance = factory({});
         return instance.id === tool.id;
@@ -246,24 +297,24 @@ function prepareTools({
           toolSpec: {
             name: tool.name,
             inputSchema: {
-              json: (0, import_provider_utils2.asSchema)(fullToolDefinition.inputSchema).jsonSchema
+              json: await (0, import_provider_utils2.asSchema)(fullToolDefinition.inputSchema).jsonSchema
             }
           }
         });
       } else {
-        toolWarnings.push({ type: "unsupported-tool", tool });
+        toolWarnings.push({ type: "unsupported", feature: "tool ${tool.id}" });
       }
     }
   } else {
-    for (const tool of providerDefinedTools) {
-      toolWarnings.push({ type: "unsupported-tool", tool });
+    for (const tool of ProviderTools) {
+      toolWarnings.push({ type: "unsupported", feature: `tool ${tool.id}` });
     }
   }
   for (const tool of functionTools) {
     bedrockTools.push({
       toolSpec: {
         name: tool.name,
-        description: tool.description,
+        ...((_a = tool.description) == null ? void 0 : _a.trim()) !== "" ? { description: tool.description } : {},
         inputSchema: {
           json: tool.inputSchema
         }
@@ -311,7 +362,17 @@ function getCachePoint(providerMetadata) {
   var _a;
   return (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.cachePoint;
 }
+async function shouldEnableCitations(providerMetadata) {
+  var _a, _b;
+  const bedrockOptions = await (0, import_provider_utils3.parseProviderOptions)({
+    provider: "bedrock",
+    providerOptions: providerMetadata,
+    schema: bedrockFilePartProviderOptions
+  });
+  return (_b = (_a = bedrockOptions == null ? void 0 : bedrockOptions.citations) == null ? void 0 : _a.enabled) != null ? _b : false;
+}
 async function convertToBedrockChatMessages(prompt) {
+  var _a, _b;
   const blocks = groupIntoBlocks(prompt);
   let system = [];
   const messages = [];
@@ -371,11 +432,17 @@ async function convertToBedrockChatMessages(prompt) {
                           message: "File mime type is required in user message part content"
                         });
                       }
+                      const enableCitations = await shouldEnableCitations(
+                        part.providerOptions
+                      );
                       bedrockContent.push({
                         document: {
                           format: getBedrockDocumentFormat(part.mediaType),
-                          name: generateDocumentName(),
-                          source: { bytes: (0, import_provider_utils3.convertToBase64)(part.data) }
+                          name: (_a = part.filename) != null ? _a : generateDocumentName(),
+                          source: { bytes: (0, import_provider_utils3.convertToBase64)(part.data) },
+                          ...enableCitations && {
+                            citations: { enabled: true }
+                          }
                         }
                       });
                     }
@@ -395,7 +462,7 @@ async function convertToBedrockChatMessages(prompt) {
                       switch (contentPart.type) {
                         case "text":
                           return { text: contentPart.text };
-                        case "media":
+                        case "image-data":
                           if (!contentPart.mediaType.startsWith("image/")) {
                             throw new import_provider3.UnsupportedFunctionalityError({
                               functionality: `media type: ${contentPart.mediaType}`
@@ -410,6 +477,11 @@ async function convertToBedrockChatMessages(prompt) {
                               source: { bytes: contentPart.data }
                             }
                           };
+                        default: {
+                          throw new import_provider3.UnsupportedFunctionalityError({
+                            functionality: `unsupported tool content part type: ${contentPart.type}`
+                          });
+                        }
                       }
                     });
                     break;
@@ -418,6 +490,11 @@ async function convertToBedrockChatMessages(prompt) {
                   case "error-text":
                     toolResultContent = [{ text: output.value }];
                     break;
+                  case "execution-denied":
+                    toolResultContent = [
+                      { text: (_b = output.reason) != null ? _b : "Tool execution denied." }
+                    ];
+                    break;
                   case "json":
                   case "error-json":
                   default:
@@ -616,7 +693,7 @@ function groupIntoBlocks(prompt) {
 }
 
 // src/map-bedrock-finish-reason.ts
-function mapBedrockFinishReason(finishReason) {
+function mapBedrockFinishReason(finishReason, isJsonResponseFromTool) {
   switch (finishReason) {
     case "stop_sequence":
     case "end_turn":
@@ -627,7 +704,7 @@ function mapBedrockFinishReason(finishReason) {
     case "guardrail_intervened":
       return "content-filter";
     case "tool_use":
-      return "tool-calls";
+      return isJsonResponseFromTool ? "stop" : "tool-calls";
     default:
       return "unknown";
   }
@@ -659,7 +736,7 @@ var BedrockChatLanguageModel = class {
     toolChoice,
     providerOptions
   }) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const bedrockOptions = (_a = await (0, import_provider_utils4.parseProviderOptions)({
       provider: "bedrock",
       providerOptions,
@@ -668,46 +745,53 @@ var BedrockChatLanguageModel = class {
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "frequencyPenalty"
+        type: "unsupported",
+        feature: "frequencyPenalty"
       });
     }
     if (presencePenalty != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "presencePenalty"
+        type: "unsupported",
+        feature: "presencePenalty"
       });
     }
     if (seed != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "seed"
+        type: "unsupported",
+        feature: "seed"
       });
     }
+    if (temperature != null && temperature > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: "temperature",
+        details: `${temperature} exceeds bedrock maximum of 1.0. clamped to 1.0`
+      });
+      temperature = 1;
+    } else if (temperature != null && temperature < 0) {
+      warnings.push({
+        type: "unsupported",
+        feature: "temperature",
+        details: `${temperature} is below bedrock minimum of 0. clamped to 0`
+      });
+      temperature = 0;
+    }
     if (responseFormat != null && responseFormat.type !== "text" && responseFormat.type !== "json") {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "responseFormat",
+        type: "unsupported",
+        feature: "responseFormat",
         details: "Only text and json response formats are supported."
       });
     }
-    if (tools != null && (responseFormat == null ? void 0 : responseFormat.type) === "json") {
-      if (tools.length > 0) {
-        warnings.push({
-          type: "other",
-          message: "JSON response format does not support tools. The provided tools are ignored."
-        });
-      }
-    }
     const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null ? {
       type: "function",
       name: "json",
       description: "Respond with a JSON object.",
       inputSchema: responseFormat.schema
     } : void 0;
-    const { toolConfig, additionalTools, toolWarnings, betas } = prepareTools({
-      tools: jsonResponseTool ? [jsonResponseTool, ...tools != null ? tools : []] : tools,
-      toolChoice: jsonResponseTool != null ? { type: "tool", toolName: jsonResponseTool.name } : toolChoice,
+    const { toolConfig, additionalTools, toolWarnings, betas } = await prepareTools({
+      tools: jsonResponseTool ? [...tools != null ? tools : [], jsonResponseTool] : tools,
+      toolChoice: jsonResponseTool != null ? { type: "required" } : toolChoice,
       modelId: this.modelId
     });
     warnings.push(...toolWarnings);
@@ -717,8 +801,18 @@ var BedrockChatLanguageModel = class {
         ...additionalTools
       };
     }
-    const isThinking = ((_b = bedrockOptions.reasoningConfig) == null ? void 0 : _b.type) === "enabled";
-    const thinkingBudget = (_c = bedrockOptions.reasoningConfig) == null ? void 0 : _c.budgetTokens;
+    if (betas.size > 0 || bedrockOptions.anthropicBeta) {
+      const existingBetas = (_b = bedrockOptions.anthropicBeta) != null ? _b : [];
+      const mergedBetas = betas.size > 0 ? [...existingBetas, ...Array.from(betas)] : existingBetas;
+      bedrockOptions.additionalModelRequestFields = {
+        ...bedrockOptions.additionalModelRequestFields,
+        anthropic_beta: mergedBetas
+      };
+    }
+    const isAnthropicModel = this.modelId.includes("anthropic");
+    const isThinkingRequested = ((_c = bedrockOptions.reasoningConfig) == null ? void 0 : _c.type) === "enabled";
+    const thinkingBudget = (_d = bedrockOptions.reasoningConfig) == null ? void 0 : _d.budgetTokens;
+    const isAnthropicThinkingEnabled = isAnthropicModel && isThinkingRequested;
     const inferenceConfig = {
       ...maxOutputTokens != null && { maxTokens: maxOutputTokens },
       ...temperature != null && { temperature },
@@ -726,7 +820,7 @@ var BedrockChatLanguageModel = class {
       ...topK != null && { topK },
       ...stopSequences != null && { stopSequences }
     };
-    if (isThinking && thinkingBudget != null) {
+    if (isAnthropicThinkingEnabled && thinkingBudget != null) {
       if (inferenceConfig.maxTokens != null) {
         inferenceConfig.maxTokens += thinkingBudget;
       } else {
@@ -735,36 +829,60 @@ var BedrockChatLanguageModel = class {
       bedrockOptions.additionalModelRequestFields = {
         ...bedrockOptions.additionalModelRequestFields,
         thinking: {
-          type: (_d = bedrockOptions.reasoningConfig) == null ? void 0 : _d.type,
+          type: (_e = bedrockOptions.reasoningConfig) == null ? void 0 : _e.type,
           budget_tokens: thinkingBudget
         }
       };
+    } else if (!isAnthropicModel && thinkingBudget != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "budgetTokens",
+        details: "budgetTokens applies only to Anthropic models on Bedrock and will be ignored for this model."
+      });
+    }
+    const maxReasoningEffort = (_f = bedrockOptions.reasoningConfig) == null ? void 0 : _f.maxReasoningEffort;
+    if (maxReasoningEffort != null && !isAnthropicModel) {
+      bedrockOptions.additionalModelRequestFields = {
+        ...bedrockOptions.additionalModelRequestFields,
+        reasoningConfig: {
+          ...((_g = bedrockOptions.reasoningConfig) == null ? void 0 : _g.type) != null && {
+            type: bedrockOptions.reasoningConfig.type
+          },
+          maxReasoningEffort
+        }
+      };
+    } else if (maxReasoningEffort != null && isAnthropicModel) {
+      warnings.push({
+        type: "unsupported",
+        feature: "maxReasoningEffort",
+        details: "maxReasoningEffort applies only to Amazon Nova models on Bedrock and will be ignored for this model."
+      });
     }
-    if (isThinking && inferenceConfig.temperature != null) {
+    if (isAnthropicThinkingEnabled && inferenceConfig.temperature != null) {
       delete inferenceConfig.temperature;
       warnings.push({
-        type: "unsupported-setting",
-        setting: "temperature",
+        type: "unsupported",
+        feature: "temperature",
         details: "temperature is not supported when thinking is enabled"
       });
     }
-    if (isThinking && inferenceConfig.topP != null) {
+    if (isAnthropicThinkingEnabled && inferenceConfig.topP != null) {
       delete inferenceConfig.topP;
       warnings.push({
-        type: "unsupported-setting",
-        setting: "topP",
+        type: "unsupported",
+        feature: "topP",
         details: "topP is not supported when thinking is enabled"
       });
     }
-    if (isThinking && inferenceConfig.topK != null) {
+    if (isAnthropicThinkingEnabled && inferenceConfig.topK != null) {
       delete inferenceConfig.topK;
       warnings.push({
-        type: "unsupported-setting",
-        setting: "topK",
+        type: "unsupported",
+        feature: "topK",
         details: "topK is not supported when thinking is enabled"
       });
     }
-    const hasAnyTools = ((_f = (_e = toolConfig.tools) == null ? void 0 : _e.length) != null ? _f : 0) > 0 || additionalTools;
+    const hasAnyTools = ((_i = (_h = toolConfig.tools) == null ? void 0 : _h.length) != null ? _i : 0) > 0 || additionalTools;
     let filteredPrompt = prompt;
     if (!hasAnyTools) {
       const hasToolContent = prompt.some(
@@ -784,14 +902,18 @@ var BedrockChatLanguageModel = class {
           (message) => message.role === "system" || message.content.length > 0
         );
         warnings.push({
-          type: "unsupported-setting",
-          setting: "toolContent",
+          type: "unsupported",
+          feature: "toolContent",
           details: "Tool calls and results removed from conversation because Bedrock does not support tool content without active tools."
         });
       }
     }
     const { system, messages } = await convertToBedrockChatMessages(filteredPrompt);
-    const { reasoningConfig: _, ...filteredBedrockOptions } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
+    const {
+      reasoningConfig: _,
+      additionalModelRequestFields: __,
+      ...filteredBedrockOptions
+    } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
     return {
       command: {
         system,
@@ -809,27 +931,21 @@ var BedrockChatLanguageModel = class {
     };
   }
   async getHeaders({
-    betas,
     headers
   }) {
-    return (0, import_provider_utils4.combineHeaders)(
-      await (0, import_provider_utils4.resolve)(this.config.headers),
-      betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {},
-      headers
-    );
+    return (0, import_provider_utils4.combineHeaders)(await (0, import_provider_utils4.resolve)(this.config.headers), headers);
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const {
       command: args,
       warnings,
-      usesJsonResponseTool,
-      betas
+      usesJsonResponseTool
     } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse`;
     const { value: response, responseHeaders } = await (0, import_provider_utils4.postJsonToApi)({
       url,
-      headers: await this.getHeaders({ betas, headers: options.headers }),
+      headers: await this.getHeaders({ headers: options.headers }),
       body: args,
       failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
         errorSchema: BedrockErrorSchema,
@@ -845,11 +961,10 @@ var BedrockChatLanguageModel = class {
       fetch: this.config.fetch
     });
     const content = [];
+    let isJsonResponseFromTool = false;
     for (const part of response.output.message.content) {
       if (part.text) {
-        if (!usesJsonResponseTool) {
-          content.push({ type: "text", text: part.text });
-        }
+        content.push({ type: "text", text: part.text });
       }
       if (part.reasoningContent) {
         if ("reasoningText" in part.reasoningContent) {
@@ -878,21 +993,24 @@ var BedrockChatLanguageModel = class {
         }
       }
       if (part.toolUse) {
-        content.push(
-          // when a json response tool is used, the tool call becomes the text:
-          usesJsonResponseTool ? {
+        const isJsonResponseTool = usesJsonResponseTool && part.toolUse.name === "json";
+        if (isJsonResponseTool) {
+          isJsonResponseFromTool = true;
+          content.push({
             type: "text",
             text: JSON.stringify(part.toolUse.input)
-          } : {
+          });
+        } else {
+          content.push({
             type: "tool-call",
             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()}`,
-            input: JSON.stringify((_g = (_f = part.toolUse) == null ? void 0 : _f.input) != null ? _g : "")
-          }
-        );
+            input: JSON.stringify((_g = (_f = part.toolUse) == null ? void 0 : _f.input) != null ? _g : {})
+          });
+        }
       }
     }
-    const providerMetadata = response.trace || response.usage || usesJsonResponseTool ? {
+    const providerMetadata = response.trace || response.usage || isJsonResponseFromTool ? {
       bedrock: {
         ...response.trace && typeof response.trace === "object" ? { trace: response.trace } : {},
         ...((_h = response.usage) == null ? void 0 : _h.cacheWriteInputTokens) != null && {
@@ -900,20 +1018,16 @@ var BedrockChatLanguageModel = class {
             cacheWriteInputTokens: response.usage.cacheWriteInputTokens
           }
         },
-        ...usesJsonResponseTool && { isJsonResponseFromTool: true }
+        ...isJsonResponseFromTool && { isJsonResponseFromTool: true }
       }
     } : void 0;
     return {
       content,
       finishReason: mapBedrockFinishReason(
-        response.stopReason
+        response.stopReason,
+        isJsonResponseFromTool
       ),
-      usage: {
-        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
-      },
+      usage: convertBedrockUsage(response.usage),
       response: {
         // TODO add id, timestamp, etc
         headers: responseHeaders
@@ -926,13 +1040,12 @@ var BedrockChatLanguageModel = class {
     const {
       command: args,
       warnings,
-      usesJsonResponseTool,
-      betas
+      usesJsonResponseTool
     } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse-stream`;
     const { value: response, responseHeaders } = await (0, import_provider_utils4.postJsonToApi)({
       url,
-      headers: await this.getHeaders({ betas, headers: options.headers }),
+      headers: await this.getHeaders({ headers: options.headers }),
       body: args,
       failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
         errorSchema: BedrockErrorSchema,
@@ -943,12 +1056,9 @@ var BedrockChatLanguageModel = class {
       fetch: this.config.fetch
     });
     let finishReason = "unknown";
-    const usage = {
-      inputTokens: void 0,
-      outputTokens: void 0,
-      totalTokens: void 0
-    };
+    let usage = void 0;
     let providerMetadata = void 0;
+    let isJsonResponseFromTool = false;
     const contentBlocks = {};
     return {
       stream: response.pipeThrough(
@@ -957,7 +1067,7 @@ var BedrockChatLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i;
             function enqueueError(bedrockError) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: bedrockError });
@@ -988,15 +1098,15 @@ var BedrockChatLanguageModel = class {
             }
             if (value.messageStop) {
               finishReason = mapBedrockFinishReason(
-                value.messageStop.stopReason
+                value.messageStop.stopReason,
+                isJsonResponseFromTool
               );
             }
             if (value.metadata) {
-              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 ? {
+              if (value.metadata.usage) {
+                usage = value.metadata.usage;
+              }
+              const cacheUsage = ((_a = value.metadata.usage) == null ? void 0 : _a.cacheWriteInputTokens) != null ? {
                 usage: {
                   cacheWriteInputTokens: value.metadata.usage.cacheWriteInputTokens
                 }
@@ -1004,19 +1114,16 @@ var BedrockChatLanguageModel = class {
               const trace = value.metadata.trace ? {
                 trace: value.metadata.trace
               } : void 0;
-              if (cacheUsage || trace || usesJsonResponseTool) {
+              if (cacheUsage || trace) {
                 providerMetadata = {
                   bedrock: {
                     ...cacheUsage,
-                    ...trace,
-                    ...usesJsonResponseTool && {
-                      isJsonResponseFromTool: true
-                    }
+                    ...trace
                   }
                 };
               }
             }
-            if (((_j = value.contentBlockStart) == null ? void 0 : _j.contentBlockIndex) != null && !((_l = (_k = value.contentBlockStart) == null ? void 0 : _k.start) == null ? void 0 : _l.toolUse)) {
+            if (((_b = value.contentBlockStart) == null ? void 0 : _b.contentBlockIndex) != null && !((_d = (_c = value.contentBlockStart) == null ? void 0 : _c.start) == null ? void 0 : _d.toolUse)) {
               const blockIndex = value.contentBlockStart.contentBlockIndex;
               contentBlocks[blockIndex] = { type: "text" };
               controller.enqueue({
@@ -1024,26 +1131,22 @@ var BedrockChatLanguageModel = class {
                 id: String(blockIndex)
               });
             }
-            if (((_m = value.contentBlockDelta) == null ? void 0 : _m.delta) && "text" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.text) {
+            if (((_e = value.contentBlockDelta) == null ? void 0 : _e.delta) && "text" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.text) {
               const blockIndex = value.contentBlockDelta.contentBlockIndex || 0;
               if (contentBlocks[blockIndex] == null) {
                 contentBlocks[blockIndex] = { type: "text" };
-                if (!usesJsonResponseTool) {
-                  controller.enqueue({
-                    type: "text-start",
-                    id: String(blockIndex)
-                  });
-                }
-              }
-              if (!usesJsonResponseTool) {
                 controller.enqueue({
-                  type: "text-delta",
-                  id: String(blockIndex),
-                  delta: value.contentBlockDelta.delta.text
+                  type: "text-start",
+                  id: String(blockIndex)
                 });
               }
+              controller.enqueue({
+                type: "text-delta",
+                id: String(blockIndex),
+                delta: value.contentBlockDelta.delta.text
+              });
             }
-            if (((_n = value.contentBlockStop) == null ? void 0 : _n.contentBlockIndex) != null) {
+            if (((_f = value.contentBlockStop) == null ? void 0 : _f.contentBlockIndex) != null) {
               const blockIndex = value.contentBlockStop.contentBlockIndex;
               const contentBlock = contentBlocks[blockIndex];
               if (contentBlock != null) {
@@ -1053,14 +1156,13 @@ var BedrockChatLanguageModel = class {
                     id: String(blockIndex)
                   });
                 } else if (contentBlock.type === "text") {
-                  if (!usesJsonResponseTool) {
-                    controller.enqueue({
-                      type: "text-end",
-                      id: String(blockIndex)
-                    });
-                  }
+                  controller.enqueue({
+                    type: "text-end",
+                    id: String(blockIndex)
+                  });
                 } else if (contentBlock.type === "tool-call") {
-                  if (usesJsonResponseTool) {
+                  if (contentBlock.isJsonResponseTool) {
+                    isJsonResponseFromTool = true;
                     controller.enqueue({
                       type: "text-start",
                       id: String(blockIndex)
@@ -1083,14 +1185,14 @@ var BedrockChatLanguageModel = class {
                       type: "tool-call",
                       toolCallId: contentBlock.toolCallId,
                       toolName: contentBlock.toolName,
-                      input: contentBlock.jsonText
+                      input: contentBlock.jsonText === "" ? "{}" : contentBlock.jsonText
                     });
                   }
                 }
                 delete contentBlocks[blockIndex];
               }
             }
-            if (((_o = value.contentBlockDelta) == null ? void 0 : _o.delta) && "reasoningContent" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.reasoningContent) {
+            if (((_g = value.contentBlockDelta) == null ? void 0 : _g.delta) && "reasoningContent" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.reasoningContent) {
               const blockIndex = value.contentBlockDelta.contentBlockIndex || 0;
               const reasoningContent = value.contentBlockDelta.delta.reasoningContent;
               if ("text" in reasoningContent && reasoningContent.text) {
@@ -1131,16 +1233,18 @@ var BedrockChatLanguageModel = class {
               }
             }
             const contentBlockStart = value.contentBlockStart;
-            if (((_p = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _p.toolUse) != null) {
+            if (((_h = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _h.toolUse) != null) {
               const toolUse = contentBlockStart.start.toolUse;
               const blockIndex = contentBlockStart.contentBlockIndex;
+              const isJsonResponseTool = usesJsonResponseTool && toolUse.name === "json";
               contentBlocks[blockIndex] = {
                 type: "tool-call",
                 toolCallId: toolUse.toolUseId,
                 toolName: toolUse.name,
-                jsonText: ""
+                jsonText: "",
+                isJsonResponseTool
               };
-              if (!usesJsonResponseTool) {
+              if (!isJsonResponseTool) {
                 controller.enqueue({
                   type: "tool-input-start",
                   id: toolUse.toolUseId,
@@ -1153,8 +1257,8 @@ var BedrockChatLanguageModel = class {
               const blockIndex = contentBlockDelta.contentBlockIndex;
               const contentBlock = contentBlocks[blockIndex];
               if ((contentBlock == null ? void 0 : contentBlock.type) === "tool-call") {
-                const delta = (_q = contentBlockDelta.delta.toolUse.input) != null ? _q : "";
-                if (!usesJsonResponseTool) {
+                const delta = (_i = contentBlockDelta.delta.toolUse.input) != null ? _i : "";
+                if (!contentBlock.isJsonResponseTool) {
                   controller.enqueue({
                     type: "tool-input-delta",
                     id: contentBlock.toolCallId,
@@ -1166,10 +1270,24 @@ var BedrockChatLanguageModel = class {
             }
           },
           flush(controller) {
+            if (isJsonResponseFromTool) {
+              if (providerMetadata) {
+                providerMetadata.bedrock = {
+                  ...providerMetadata.bedrock,
+                  isJsonResponseFromTool: true
+                };
+              } else {
+                providerMetadata = {
+                  bedrock: {
+                    isJsonResponseFromTool: true
+                  }
+                };
+              }
+            }
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage,
+              usage: convertBedrockUsage(usage),
               ...providerMetadata && { providerMetadata }
             });
           }
@@ -1361,6 +1479,7 @@ var BedrockEmbeddingModel = class {
       abortSignal
     });
     return {
+      warnings: [],
       embeddings: [response.embedding],
       usage: { tokens: response.inputTextTokenCount }
     };
@@ -1431,8 +1550,8 @@ var BedrockImageModel = class {
     };
     if (aspectRatio != void 0) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "aspectRatio",
+        type: "unsupported",
+        feature: "aspectRatio",
         details: "This model does not support aspect ratio. Use `size` instead."
       });
     }
@@ -1468,38 +1587,21 @@ var bedrockImageResponseSchema = import_v46.z.object({
   images: import_v46.z.array(import_v46.z.string())
 });
 
-// src/headers-utils.ts
-function extractHeaders(headers) {
-  let originalHeaders = {};
-  if (headers) {
-    if (headers instanceof Headers) {
-      originalHeaders = convertHeadersToRecord(headers);
-    } else if (Array.isArray(headers)) {
-      for (const [k, v] of headers) {
-        originalHeaders[k.toLowerCase()] = v;
-      }
-    } else {
-      originalHeaders = Object.fromEntries(
-        Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v])
-      );
-    }
-  }
-  return originalHeaders;
-}
-function convertHeadersToRecord(headers) {
-  return Object.fromEntries([...headers]);
-}
-
 // src/bedrock-sigv4-fetch.ts
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
 var import_aws4fetch = require("aws4fetch");
+
+// src/version.ts
+var VERSION = true ? "4.0.0-beta.100" : "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)(
-      extractHeaders(request == null ? void 0 : request.headers),
-      extractHeaders(init == null ? void 0 : init.headers)
+      (0, import_provider_utils7.normalizeHeaders)(request == null ? void 0 : request.headers),
+      (0, import_provider_utils7.normalizeHeaders)(init == null ? void 0 : init.headers)
     );
     const headersWithUserAgent = (0, import_provider_utils7.withUserAgentSuffix)(
       originalHeaders,
@@ -1535,7 +1637,7 @@ function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
       service: "bedrock"
     });
     const signingResult = await signer.sign();
-    const signedHeaders = convertHeadersToRecord(signingResult.headers);
+    const signedHeaders = (0, import_provider_utils7.normalizeHeaders)(signingResult.headers);
     const combinedHeaders = (0, import_provider_utils7.combineHeaders)(headersWithUserAgent, signedHeaders);
     return fetch(input, {
       ...init,
@@ -1557,7 +1659,7 @@ function prepareBodyString(body) {
 }
 function createApiKeyFetchFunction(apiKey, fetch = globalThis.fetch) {
   return async (input, init) => {
-    const originalHeaders = extractHeaders(init == null ? void 0 : init.headers);
+    const originalHeaders = (0, import_provider_utils7.normalizeHeaders)(init == null ? void 0 : init.headers);
     const headersWithUserAgent = (0, import_provider_utils7.withUserAgentSuffix)(
       originalHeaders,
       `ai-sdk/amazon-bedrock/${VERSION}`,
@@ -1573,15 +1675,132 @@ function createApiKeyFetchFunction(apiKey, fetch = globalThis.fetch) {
   };
 }
 
+// src/reranking/bedrock-reranking-model.ts
+var import_provider_utils10 = require("@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()
+        })
+      ),
+      nextToken: import_v47.z.string().optional()
+    })
+  )
+);
+
+// src/reranking/bedrock-reranking-options.ts
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var import_v48 = require("zod/v4");
+var bedrockRerankingOptionsSchema = (0, import_provider_utils9.lazySchema)(
+  () => (0, import_provider_utils9.zodSchema)(
+    import_v48.z.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(),
+      /**
+       * Additional model request fields to pass to the model.
+       */
+      additionalModelRequestFields: import_v48.z.record(import_v48.z.string(), import_v48.z.any()).optional()
+    })
+  )
+);
+
+// src/reranking/bedrock-reranking-model.ts
+var BedrockRerankingModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.provider = "amazon-bedrock";
+  }
+  async doRerank({
+    documents,
+    headers,
+    query,
+    topN,
+    abortSignal,
+    providerOptions
+  }) {
+    const bedrockOptions = await (0, import_provider_utils10.parseProviderOptions)({
+      provider: "bedrock",
+      providerOptions,
+      schema: bedrockRerankingOptionsSchema
+    });
+    const {
+      value: response,
+      responseHeaders,
+      rawValue
+    } = await (0, import_provider_utils10.postJsonToApi)({
+      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)
+      ),
+      body: {
+        nextToken: bedrockOptions == null ? void 0 : bedrockOptions.nextToken,
+        queries: [
+          {
+            textQuery: { text: query },
+            type: "TEXT"
+          }
+        ],
+        rerankingConfiguration: {
+          bedrockRerankingConfiguration: {
+            modelConfiguration: {
+              modelArn: `arn:aws:bedrock:${this.config.region}::foundation-model/${this.modelId}`,
+              additionalModelRequestFields: bedrockOptions == null ? void 0 : bedrockOptions.additionalModelRequestFields
+            },
+            numberOfResults: topN
+          },
+          type: "BEDROCK_RERANKING_MODEL"
+        },
+        sources: documents.values.map((value) => ({
+          type: "INLINE",
+          inlineDocumentSource: documents.type === "text" ? {
+            type: "TEXT",
+            textDocument: { text: value }
+          } : {
+            type: "JSON",
+            jsonDocument: value
+          }
+        }))
+      },
+      failedResponseHandler: (0, import_provider_utils10.createJsonErrorResponseHandler)({
+        errorSchema: BedrockErrorSchema,
+        errorToMessage: (error) => `${error.type}: ${error.message}`
+      }),
+      successfulResponseHandler: (0, import_provider_utils10.createJsonResponseHandler)(
+        bedrockRerankingResponseSchema
+      ),
+      fetch: this.config.fetch,
+      abortSignal
+    });
+    return {
+      ranking: response.results,
+      response: {
+        headers: responseHeaders,
+        body: rawValue
+      }
+    };
+  }
+};
+
 // src/bedrock-provider.ts
 function createAmazonBedrock(options = {}) {
-  const rawApiKey = (0, import_provider_utils8.loadOptionalSetting)({
+  const rawApiKey = (0, import_provider_utils11.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_utils8.loadSetting)({
+    const region = (0, import_provider_utils11.loadSetting)({
       settingValue: options.region,
       settingName: "region",
       environmentVariableName: "AWS_REGION",
@@ -1603,19 +1822,19 @@ function createAmazonBedrock(options = {}) {
     try {
       return {
         region,
-        accessKeyId: (0, import_provider_utils8.loadSetting)({
+        accessKeyId: (0, import_provider_utils11.loadSetting)({
           settingValue: options.accessKeyId,
           settingName: "accessKeyId",
           environmentVariableName: "AWS_ACCESS_KEY_ID",
           description: "AWS access key ID"
         }),
-        secretAccessKey: (0, import_provider_utils8.loadSetting)({
+        secretAccessKey: (0, import_provider_utils11.loadSetting)({
           settingValue: options.secretAccessKey,
           settingName: "secretAccessKey",
           environmentVariableName: "AWS_SECRET_ACCESS_KEY",
           description: "AWS secret access key"
         }),
-        sessionToken: (0, import_provider_utils8.loadOptionalSetting)({
+        sessionToken: (0, import_provider_utils11.loadOptionalSetting)({
           settingValue: options.sessionToken,
           environmentVariableName: "AWS_SESSION_TOKEN"
         })
@@ -1641,10 +1860,15 @@ Original error: ${errorMessage}`
       throw error;
     }
   }, options.fetch);
-  const getBaseUrl = () => {
+  const getHeaders = () => {
+    var _a;
+    const baseHeaders = (_a = options.headers) != null ? _a : {};
+    return (0, import_provider_utils11.withUserAgentSuffix)(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION}`);
+  };
+  const getBedrockRuntimeBaseUrl = () => {
     var _a, _b;
-    return (_b = (0, import_provider_utils8.withoutTrailingSlash)(
-      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${(0, import_provider_utils8.loadSetting)({
+    return (_b = (0, import_provider_utils11.withoutTrailingSlash)(
+      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${(0, import_provider_utils11.loadSetting)({
         settingValue: options.region,
         settingName: "region",
         environmentVariableName: "AWS_REGION",
@@ -1652,16 +1876,22 @@ Original error: ${errorMessage}`
       })}.amazonaws.com`
     )) != null ? _b : `https://bedrock-runtime.us-east-1.amazonaws.com`;
   };
-  const getHeaders = () => {
-    var _a;
-    const baseHeaders = (_a = options.headers) != null ? _a : {};
-    return (0, import_provider_utils8.withUserAgentSuffix)(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION}`);
+  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)({
+        settingValue: options.region,
+        settingName: "region",
+        environmentVariableName: "AWS_REGION",
+        description: "AWS region"
+      })}.amazonaws.com`
+    )) != null ? _b : `https://bedrock-agent-runtime.us-west-2.amazonaws.com`;
   };
   const createChatModel = (modelId) => new BedrockChatLanguageModel(modelId, {
-    baseUrl: getBaseUrl,
+    baseUrl: getBedrockRuntimeBaseUrl,
     headers: getHeaders,
     fetch: fetchFunction,
-    generateId: import_provider_utils8.generateId
+    generateId: import_provider_utils11.generateId
   });
   const provider = function(modelId) {
     if (new.target) {
@@ -1672,21 +1902,36 @@ Original error: ${errorMessage}`
     return createChatModel(modelId);
   };
   const createEmbeddingModel = (modelId) => new BedrockEmbeddingModel(modelId, {
-    baseUrl: getBaseUrl,
+    baseUrl: getBedrockRuntimeBaseUrl,
     headers: getHeaders,
     fetch: fetchFunction
   });
   const createImageModel = (modelId) => new BedrockImageModel(modelId, {
-    baseUrl: getBaseUrl,
+    baseUrl: getBedrockRuntimeBaseUrl,
+    headers: getHeaders,
+    fetch: fetchFunction
+  });
+  const createRerankingModel = (modelId) => new BedrockRerankingModel(modelId, {
+    baseUrl: getBedrockAgentRuntimeBaseUrl,
+    region: (0, import_provider_utils11.loadSetting)({
+      settingValue: options.region,
+      settingName: "region",
+      environmentVariableName: "AWS_REGION",
+      description: "AWS region"
+    }),
     headers: getHeaders,
     fetch: fetchFunction
   });
+  provider.specificationVersion = "v3";
   provider.languageModel = createChatModel;
   provider.embedding = createEmbeddingModel;
+  provider.embeddingModel = createEmbeddingModel;
   provider.textEmbedding = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.image = createImageModel;
   provider.imageModel = createImageModel;
+  provider.reranking = createRerankingModel;
+  provider.rerankingModel = createRerankingModel;
   provider.tools = import_internal2.anthropicTools;
   return provider;
 }