@ai-sdk/amazon-bedrock 3.0.0-canary.9 → 3.0.1

package/dist/index.js

@@ -26,11 +26,12 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/bedrock-provider.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var import_internal2 = require("@ai-sdk/anthropic/internal");
 
 // src/bedrock-chat-language-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_v43 = require("zod/v4");
 
 // src/bedrock-api-types.ts
 var BEDROCK_CACHE_POINT = {
@@ -48,27 +49,44 @@ var BEDROCK_STOP_REASONS = [
   "tool-calls",
   "tool_use"
 ];
+var BEDROCK_IMAGE_MIME_TYPES = {
+  "image/jpeg": "jpeg",
+  "image/png": "png",
+  "image/gif": "gif",
+  "image/webp": "webp"
+};
+var BEDROCK_DOCUMENT_MIME_TYPES = {
+  "application/pdf": "pdf",
+  "text/csv": "csv",
+  "application/msword": "doc",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/vnd.ms-excel": "xls",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "text/html": "html",
+  "text/plain": "txt",
+  "text/markdown": "md"
+};
 
 // src/bedrock-chat-options.ts
-var import_zod = require("zod");
-var bedrockProviderOptions = import_zod.z.object({
+var import_v4 = require("zod/v4");
+var bedrockProviderOptions = import_v4.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")]).nullish(),
-    budgetTokens: import_zod.z.number().nullish()
-  }).nullish()
+  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()
 });
 
 // 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()
+var import_v42 = require("zod/v4");
+var BedrockErrorSchema = import_v42.z.object({
+  message: import_v42.z.string(),
+  type: import_v42.z.string().nullish()
 });
 
 // src/bedrock-event-stream-response-handler.ts
@@ -88,7 +106,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);
@@ -109,7 +127,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;
@@ -118,7 +136,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
                 });
@@ -144,87 +162,155 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
 
 // src/bedrock-prepare-tools.ts
 var import_provider2 = require("@ai-sdk/provider");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_internal = require("@ai-sdk/anthropic/internal");
 function prepareTools({
   tools,
-  toolChoice
+  toolChoice,
+  modelId
 }) {
-  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
-  if (tools == null) {
+  const toolWarnings = [];
+  const betas = /* @__PURE__ */ new Set();
+  if (tools == null || tools.length === 0) {
     return {
-      toolConfig: { tools: void 0, toolChoice: void 0 },
-      toolWarnings: []
+      toolConfig: {},
+      additionalTools: void 0,
+      betas,
+      toolWarnings
     };
   }
-  const toolWarnings = [];
-  const bedrockTools = [];
-  for (const tool of tools) {
-    if (tool.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool });
-    } else {
-      bedrockTools.push({
-        toolSpec: {
-          name: tool.name,
-          description: tool.description,
-          inputSchema: {
-            json: tool.parameters
-          }
-        }
+  const supportedTools = tools.filter((tool) => {
+    if (tool.type === "provider-defined" && tool.id === "anthropic.web_search_20250305") {
+      toolWarnings.push({
+        type: "unsupported-tool",
+        tool,
+        details: "The web_search_20250305 tool is not supported on Amazon Bedrock."
       });
+      return false;
     }
-  }
-  if (toolChoice == null) {
+    return true;
+  });
+  if (supportedTools.length === 0) {
     return {
-      toolConfig: { tools: bedrockTools, toolChoice: void 0 },
+      toolConfig: {},
+      additionalTools: void 0,
+      betas,
       toolWarnings
     };
   }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-      return {
-        toolConfig: { tools: bedrockTools, toolChoice: { auto: {} } },
-        toolWarnings
-      };
-    case "required":
-      return {
-        toolConfig: { tools: bedrockTools, toolChoice: { any: {} } },
-        toolWarnings
-      };
-    case "none":
-      return {
-        toolConfig: { tools: void 0, toolChoice: void 0 },
-        toolWarnings
-      };
-    case "tool":
-      return {
-        toolConfig: {
-          tools: bedrockTools,
-          toolChoice: { tool: { name: toolChoice.toolName } }
-        },
-        toolWarnings
+  const isAnthropicModel = modelId.includes("anthropic.");
+  const providerDefinedTools = supportedTools.filter(
+    (t) => t.type === "provider-defined"
+  );
+  const functionTools = supportedTools.filter((t) => t.type === "function");
+  let additionalTools = void 0;
+  const bedrockTools = [];
+  const usingAnthropicTools = isAnthropicModel && providerDefinedTools.length > 0;
+  if (usingAnthropicTools) {
+    if (functionTools.length > 0) {
+      toolWarnings.push({
+        type: "unsupported-setting",
+        setting: "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."
+      });
+    }
+    const {
+      toolChoice: preparedAnthropicToolChoice,
+      toolWarnings: anthropicToolWarnings,
+      betas: anthropicBetas
+    } = (0, import_internal.prepareTools)({
+      tools: providerDefinedTools,
+      toolChoice
+    });
+    toolWarnings.push(...anthropicToolWarnings);
+    anthropicBetas.forEach((beta) => betas.add(beta));
+    if (preparedAnthropicToolChoice) {
+      additionalTools = {
+        tool_choice: preparedAnthropicToolChoice
       };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
-        functionality: `tool choice type: ${_exhaustiveCheck}`
+    }
+    for (const tool of providerDefinedTools) {
+      const toolFactory = Object.values(import_internal.anthropicTools).find((factory) => {
+        const instance = factory({});
+        return instance.id === tool.id;
       });
+      if (toolFactory != null) {
+        const fullToolDefinition = toolFactory({});
+        bedrockTools.push({
+          toolSpec: {
+            name: tool.name,
+            inputSchema: {
+              json: (0, import_provider_utils2.asSchema)(fullToolDefinition.inputSchema).jsonSchema
+            }
+          }
+        });
+      } else {
+        toolWarnings.push({ type: "unsupported-tool", tool });
+      }
+    }
+  } else {
+    for (const tool of providerDefinedTools) {
+      toolWarnings.push({ type: "unsupported-tool", tool });
     }
   }
+  for (const tool of functionTools) {
+    bedrockTools.push({
+      toolSpec: {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: {
+          json: tool.inputSchema
+        }
+      }
+    });
+  }
+  let bedrockToolChoice = void 0;
+  if (!usingAnthropicTools && bedrockTools.length > 0 && toolChoice) {
+    const type = toolChoice.type;
+    switch (type) {
+      case "auto":
+        bedrockToolChoice = { auto: {} };
+        break;
+      case "required":
+        bedrockToolChoice = { any: {} };
+        break;
+      case "none":
+        bedrockTools.length = 0;
+        bedrockToolChoice = void 0;
+        break;
+      case "tool":
+        bedrockToolChoice = { tool: { name: toolChoice.toolName } };
+        break;
+      default: {
+        const _exhaustiveCheck = type;
+        throw new import_provider2.UnsupportedFunctionalityError({
+          functionality: `tool choice type: ${_exhaustiveCheck}`
+        });
+      }
+    }
+  }
+  const toolConfig = bedrockTools.length > 0 ? { tools: bedrockTools, toolChoice: bedrockToolChoice } : {};
+  return {
+    toolConfig,
+    additionalTools,
+    betas,
+    toolWarnings
+  };
 }
 
 // src/convert-to-bedrock-chat-messages.ts
 var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var generateFileId = (0, import_provider_utils2.createIdGenerator)({ prefix: "file", size: 16 });
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 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;
+async function convertToBedrockChatMessages(prompt) {
   const blocks = groupIntoBlocks(prompt);
   let system = [];
   const messages = [];
+  let documentCounter = 0;
+  const generateDocumentName = () => `document-${++documentCounter}`;
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i];
     const isLastBlock = i === blocks.length - 1;
@@ -266,21 +352,24 @@ function convertToBedrockChatMessages(prompt) {
                       });
                     }
                     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) }
+                          format: getBedrockImageFormat(part.mediaType),
+                          source: { bytes: (0, import_provider_utils3.convertToBase64)(part.data) }
                         }
                       });
                     } else {
+                      if (!part.mediaType) {
+                        throw new import_provider3.UnsupportedFunctionalityError({
+                          functionality: "file without mime type",
+                          message: "File mime type is required in user message part content"
+                        });
+                      }
                       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) }
+                          format: getBedrockDocumentFormat(part.mediaType),
+                          name: generateDocumentName(),
+                          source: { bytes: (0, import_provider_utils3.convertToBase64)(part.data) }
                         }
                       });
                     }
@@ -291,36 +380,46 @@ function convertToBedrockChatMessages(prompt) {
               break;
             }
             case "tool": {
-              for (let i2 = 0; i2 < content.length; i2++) {
-                const part = content[i2];
-                const toolResultContent = part.content != void 0 ? part.content.map((part2) => {
-                  switch (part2.type) {
-                    case "text":
-                      return {
-                        text: part2.text
-                      };
-                    case "image":
-                      if (!part2.mediaType) {
-                        throw new Error(
-                          "Image mime type is required in tool result part content"
-                        );
-                      }
-                      const format = part2.mediaType.split("/")[1];
-                      if (!isBedrockImageFormat(format)) {
-                        throw new Error(
-                          `Unsupported image format: ${format}`
-                        );
-                      }
-                      return {
-                        image: {
-                          format,
-                          source: {
-                            bytes: part2.data
+              for (const part of content) {
+                let toolResultContent;
+                const output = part.output;
+                switch (output.type) {
+                  case "content": {
+                    toolResultContent = output.value.map((contentPart) => {
+                      switch (contentPart.type) {
+                        case "text":
+                          return { text: contentPart.text };
+                        case "media":
+                          if (!contentPart.mediaType.startsWith("image/")) {
+                            throw new import_provider3.UnsupportedFunctionalityError({
+                              functionality: `media type: ${contentPart.mediaType}`
+                            });
                           }
-                        }
-                      };
+                          const format = getBedrockImageFormat(
+                            contentPart.mediaType
+                          );
+                          return {
+                            image: {
+                              format,
+                              source: { bytes: contentPart.data }
+                            }
+                          };
+                      }
+                    });
+                    break;
                   }
-                }) : [{ text: JSON.stringify(part.result) }];
+                  case "text":
+                  case "error-text":
+                    toolResultContent = [{ text: output.value }];
+                    break;
+                  case "json":
+                  case "error-json":
+                  default:
+                    toolResultContent = [
+                      { text: JSON.stringify(output.value) }
+                    ];
+                    break;
+                }
                 bedrockContent.push({
                   toolResult: {
                     toolUseId: part.toolCallId,
@@ -369,32 +468,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_utils3.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": {
@@ -402,7 +508,7 @@ function convertToBedrockChatMessages(prompt) {
                   toolUse: {
                     toolUseId: part.toolCallId,
                     name: part.toolName,
-                    input: part.args
+                    input: part.input
                   }
                 });
                 break;
@@ -424,8 +530,31 @@ function convertToBedrockChatMessages(prompt) {
   }
   return { system, messages };
 }
-function isBedrockImageFormat(format) {
-  return ["jpeg", "png", "gif"].includes(format);
+function getBedrockImageFormat(mimeType) {
+  if (!mimeType) {
+    throw new import_provider3.UnsupportedFunctionalityError({
+      functionality: "image without mime type",
+      message: "Image mime type is required in user message part content"
+    });
+  }
+  const format = BEDROCK_IMAGE_MIME_TYPES[mimeType];
+  if (!format) {
+    throw new import_provider3.UnsupportedFunctionalityError({
+      functionality: `image mime type: ${mimeType}`,
+      message: `Unsupported image mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_IMAGE_MIME_TYPES).join(", ")}`
+    });
+  }
+  return format;
+}
+function getBedrockDocumentFormat(mimeType) {
+  const format = BEDROCK_DOCUMENT_MIME_TYPES[mimeType];
+  if (!format) {
+    throw new import_provider3.UnsupportedFunctionalityError({
+      functionality: `file mime type: ${mimeType}`,
+      message: `Unsupported file mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_DOCUMENT_MIME_TYPES).join(", ")}`
+    });
+  }
+  return format;
 }
 function trimIfLast(isLastBlock, isLastMessage, isLastContentPart, text) {
   return isLastBlock && isLastMessage && isLastContentPart ? text.trim() : text;
@@ -502,8 +631,11 @@ var BedrockChatLanguageModel = class {
     this.config = config;
     this.specificationVersion = "v2";
     this.provider = "amazon-bedrock";
+    this.supportedUrls = {
+      // no supported urls for bedrock
+    };
   }
-  getArgs({
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -518,8 +650,8 @@ var BedrockChatLanguageModel = class {
     toolChoice,
     providerOptions
   }) {
-    var _a, _b, _c, _d, _e;
-    const bedrockOptions = (_a = (0, import_provider_utils3.parseProviderOptions)({
+    var _a, _b, _c, _d, _e, _f;
+    const bedrockOptions = (_a = await (0, import_provider_utils4.parseProviderOptions)({
       provider: "bedrock",
       providerOptions,
       schema: bedrockProviderOptions
@@ -549,14 +681,39 @@ var BedrockChatLanguageModel = class {
         setting: "topK"
       });
     }
-    if (responseFormat != null && responseFormat.type !== "text") {
+    if (responseFormat != null && responseFormat.type !== "text" && responseFormat.type !== "json") {
       warnings.push({
         type: "unsupported-setting",
         setting: "responseFormat",
-        details: "JSON response format is not supported."
+        details: "Only text and json response formats are supported."
       });
     }
-    const { system, messages } = convertToBedrockChatMessages(prompt);
+    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,
+      modelId: this.modelId
+    });
+    warnings.push(...toolWarnings);
+    if (additionalTools) {
+      bedrockOptions.additionalModelRequestFields = {
+        ...bedrockOptions.additionalModelRequestFields,
+        ...additionalTools
+      };
+    }
     const isThinking = ((_b = bedrockOptions.reasoningConfig) == null ? void 0 : _b.type) === "enabled";
     const thinkingBudget = (_c = bedrockOptions.reasoningConfig) == null ? void 0 : _c.budgetTokens;
     const inferenceConfig = {
@@ -573,7 +730,7 @@ var BedrockChatLanguageModel = class {
       }
       bedrockOptions.additionalModelRequestFields = {
         ...bedrockOptions.additionalModelRequestFields,
-        reasoningConfig: {
+        thinking: {
           type: (_d = bedrockOptions.reasoningConfig) == null ? void 0 : _d.type,
           budget_tokens: thinkingBudget
         }
@@ -595,7 +752,34 @@ var BedrockChatLanguageModel = class {
         details: "topP is not supported when thinking is enabled"
       });
     }
-    const { toolConfig, toolWarnings } = prepareTools({ tools, toolChoice });
+    const hasAnyTools = ((_f = (_e = toolConfig.tools) == null ? void 0 : _e.length) != null ? _f : 0) > 0 || additionalTools;
+    let filteredPrompt = prompt;
+    if (!hasAnyTools) {
+      const hasToolContent = prompt.some(
+        (message) => "content" in message && Array.isArray(message.content) && message.content.some(
+          (part) => part.type === "tool-call" || part.type === "tool-result"
+        )
+      );
+      if (hasToolContent) {
+        filteredPrompt = prompt.map(
+          (message) => message.role === "system" ? message : {
+            ...message,
+            content: message.content.filter(
+              (part) => part.type !== "tool-call" && part.type !== "tool-result"
+            )
+          }
+        ).filter(
+          (message) => message.role === "system" || message.content.length > 0
+        );
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "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) || {};
     return {
       command: {
         system,
@@ -604,36 +788,45 @@ var BedrockChatLanguageModel = class {
         ...Object.keys(inferenceConfig).length > 0 && {
           inferenceConfig
         },
-        ...providerOptions == null ? void 0 : providerOptions.bedrock,
-        ...((_e = toolConfig.tools) == null ? void 0 : _e.length) ? { toolConfig } : {}
+        ...filteredBedrockOptions,
+        ...toolConfig.tools !== void 0 && toolConfig.tools.length > 0 ? { toolConfig } : {}
       },
-      warnings: [...warnings, ...toolWarnings]
+      warnings,
+      usesJsonResponseTool: jsonResponseTool != null,
+      betas
     };
   }
-  async getSupportedUrls() {
-    return {
-      // no supported urls for bedrock
-    };
+  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
+    );
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
-    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,
+      usesJsonResponseTool,
+      betas
+    } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse`;
-    const { value: response, responseHeaders } = await (0, import_provider_utils3.postJsonToApi)({
+    const { value: response, responseHeaders } = await (0, import_provider_utils4.postJsonToApi)({
       url,
-      headers: (0, import_provider_utils3.combineHeaders)(
-        await (0, import_provider_utils3.resolve)(this.config.headers),
-        options.headers
-      ),
+      headers: await this.getHeaders({ betas, headers: options.headers }),
       body: args,
-      failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)({
+      failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => {
           var _a2;
           return `${(_a2 = error.message) != null ? _a2 : "Unknown error"}`;
         }
       }),
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
         BedrockResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -642,49 +835,60 @@ var BedrockChatLanguageModel = class {
     const content = [];
     for (const part of response.output.message.content) {
       if (part.text) {
-        content.push({ type: "text", text: part.text });
+        if (!usesJsonResponseTool) {
+          content.push({ type: "text", text: part.text });
+        }
       }
       if (part.reasoningContent) {
         if ("reasoningText" in part.reasoningContent) {
-          content.push({
+          const reasoning = {
             type: "reasoning",
-            reasoningType: "text",
             text: part.reasoningContent.reasoningText.text
-          });
+          };
           if (part.reasoningContent.reasoningText.signature) {
-            content.push({
-              type: "reasoning",
-              reasoningType: "signature",
-              signature: 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",
-            reasoningType: "redacted",
-            data: (_a = part.reasoningContent.redactedReasoning.data) != null ? _a : ""
+            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 : "")
-        });
+        content.push(
+          // when a json response tool is used, the tool call becomes the text:
+          usesJsonResponseTool ? {
+            type: "text",
+            text: JSON.stringify(part.toolUse.input)
+          } : {
+            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 : "")
+          }
+        );
       }
     }
-    const providerMetadata = response.trace || response.usage ? {
+    const providerMetadata = response.trace || response.usage || usesJsonResponseTool ? {
       bedrock: {
         ...response.trace && typeof response.trace === "object" ? { trace: response.trace } : {},
-        ...response.usage && {
+        ...((_h = response.usage) == null ? void 0 : _h.cacheWriteInputTokens) != null && {
           usage: {
-            cacheReadInputTokens: (_i = (_h = response.usage) == null ? void 0 : _h.cacheReadInputTokens) != null ? _i : Number.NaN,
-            cacheWriteInputTokens: (_k = (_j = response.usage) == null ? void 0 : _j.cacheWriteInputTokens) != null ? _k : Number.NaN
+            cacheWriteInputTokens: response.usage.cacheWriteInputTokens
           }
-        }
+        },
+        ...usesJsonResponseTool && { isJsonResponseFromTool: true }
       }
     } : void 0;
     return {
@@ -693,8 +897,10 @@ var BedrockChatLanguageModel = class {
         response.stopReason
       ),
       usage: {
-        inputTokens: (_l = response.usage) == null ? void 0 : _l.inputTokens,
-        outputTokens: (_m = response.usage) == null ? void 0 : _m.outputTokens
+        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
@@ -705,16 +911,18 @@ var BedrockChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    const { command: args, warnings } = this.getArgs(options);
+    const {
+      command: args,
+      warnings,
+      usesJsonResponseTool,
+      betas
+    } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse-stream`;
-    const { value: response, responseHeaders } = await (0, import_provider_utils3.postJsonToApi)({
+    const { value: response, responseHeaders } = await (0, import_provider_utils4.postJsonToApi)({
       url,
-      headers: (0, import_provider_utils3.combineHeaders)(
-        await (0, import_provider_utils3.resolve)(this.config.headers),
-        options.headers
-      ),
+      headers: await this.getHeaders({ betas, headers: options.headers }),
       body: args,
-      failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)({
+      failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
@@ -725,10 +933,11 @@ var BedrockChatLanguageModel = class {
     let finishReason = "unknown";
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let providerMetadata = void 0;
-    const toolCallContentBlocks = {};
+    const contentBlocks = {};
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -736,11 +945,14 @@ 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;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
             function enqueueError(bedrockError) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: bedrockError });
             }
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
             if (!chunk.success) {
               enqueueError(chunk.error);
               return;
@@ -770,87 +982,174 @@ var BedrockChatLanguageModel = class {
             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;
-              const cacheUsage = ((_e = value.metadata.usage) == null ? void 0 : _e.cacheReadInputTokens) != null || ((_f = value.metadata.usage) == null ? void 0 : _f.cacheWriteInputTokens) != null ? {
+              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 ? {
                 trace: value.metadata.trace
               } : void 0;
-              if (cacheUsage || trace) {
+              if (cacheUsage || trace || usesJsonResponseTool) {
                 providerMetadata = {
                   bedrock: {
                     ...cacheUsage,
-                    ...trace
+                    ...trace,
+                    ...usesJsonResponseTool && {
+                      isJsonResponseFromTool: true
+                    }
                   }
                 };
               }
             }
-            if (((_k = value.contentBlockDelta) == null ? void 0 : _k.delta) && "text" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.text) {
+            if (((_j = value.contentBlockStart) == null ? void 0 : _j.contentBlockIndex) != null && !((_l = (_k = value.contentBlockStart) == null ? void 0 : _k.start) == null ? void 0 : _l.toolUse)) {
+              const blockIndex = value.contentBlockStart.contentBlockIndex;
+              contentBlocks[blockIndex] = { type: "text" };
               controller.enqueue({
-                type: "text",
-                text: value.contentBlockDelta.delta.text
+                type: "text-start",
+                id: String(blockIndex)
               });
             }
-            if (((_l = value.contentBlockDelta) == null ? void 0 : _l.delta) && "reasoningContent" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.reasoningContent) {
+            if (((_m = value.contentBlockDelta) == null ? void 0 : _m.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
+                });
+              }
+            }
+            if (((_n = value.contentBlockStop) == null ? void 0 : _n.contentBlockIndex) != null) {
+              const blockIndex = value.contentBlockStop.contentBlockIndex;
+              const contentBlock = contentBlocks[blockIndex];
+              if (contentBlock != null) {
+                if (contentBlock.type === "reasoning") {
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: String(blockIndex)
+                  });
+                } else if (contentBlock.type === "text") {
+                  if (!usesJsonResponseTool) {
+                    controller.enqueue({
+                      type: "text-end",
+                      id: String(blockIndex)
+                    });
+                  }
+                } else if (contentBlock.type === "tool-call") {
+                  if (usesJsonResponseTool) {
+                    controller.enqueue({
+                      type: "text-start",
+                      id: String(blockIndex)
+                    });
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: String(blockIndex),
+                      delta: contentBlock.jsonText
+                    });
+                    controller.enqueue({
+                      type: "text-end",
+                      id: String(blockIndex)
+                    });
+                  } else {
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: contentBlock.toolCallId
+                    });
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: contentBlock.toolCallId,
+                      toolName: contentBlock.toolName,
+                      input: contentBlock.jsonText
+                    });
+                  }
+                }
+                delete contentBlocks[blockIndex];
+              }
+            }
+            if (((_o = value.contentBlockDelta) == null ? void 0 : _o.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) {
+                if (contentBlocks[blockIndex] == null) {
+                  contentBlocks[blockIndex] = { type: "reasoning" };
+                  controller.enqueue({
+                    type: "reasoning-start",
+                    id: String(blockIndex)
+                  });
+                }
                 controller.enqueue({
-                  type: "reasoning",
-                  reasoningType: "text",
-                  text: reasoningContent.text
+                  type: "reasoning-delta",
+                  id: String(blockIndex),
+                  delta: reasoningContent.text
                 });
               } else if ("signature" in reasoningContent && reasoningContent.signature) {
                 controller.enqueue({
-                  type: "reasoning",
-                  reasoningType: "signature",
-                  signature: reasoningContent.signature
+                  type: "reasoning-delta",
+                  id: String(blockIndex),
+                  delta: "",
+                  providerMetadata: {
+                    bedrock: {
+                      signature: reasoningContent.signature
+                    }
+                  }
                 });
               } else if ("data" in reasoningContent && reasoningContent.data) {
                 controller.enqueue({
-                  type: "reasoning",
-                  reasoningType: "redacted",
-                  data: reasoningContent.data
+                  type: "reasoning-delta",
+                  id: String(blockIndex),
+                  delta: "",
+                  providerMetadata: {
+                    bedrock: {
+                      redactedData: reasoningContent.data
+                    }
+                  }
                 });
               }
             }
             const contentBlockStart = value.contentBlockStart;
-            if (((_m = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _m.toolUse) != null) {
+            if (((_p = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _p.toolUse) != null) {
               const toolUse = contentBlockStart.start.toolUse;
-              toolCallContentBlocks[contentBlockStart.contentBlockIndex] = {
+              const blockIndex = contentBlockStart.contentBlockIndex;
+              contentBlocks[blockIndex] = {
+                type: "tool-call",
                 toolCallId: toolUse.toolUseId,
                 toolName: toolUse.name,
                 jsonText: ""
               };
+              if (!usesJsonResponseTool) {
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: toolUse.toolUseId,
+                  toolName: toolUse.name
+                });
+              }
             }
             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 : "";
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallType: "function",
-                toolCallId: contentBlock.toolCallId,
-                toolName: contentBlock.toolName,
-                argsTextDelta: delta
-              });
-              contentBlock.jsonText += delta;
-            }
-            const contentBlockStop = value.contentBlockStop;
-            if (contentBlockStop != null) {
-              const index = contentBlockStop.contentBlockIndex;
-              const contentBlock = toolCallContentBlocks[index];
-              if (contentBlock != null) {
-                controller.enqueue({
-                  type: "tool-call",
-                  toolCallType: "function",
-                  toolCallId: contentBlock.toolCallId,
-                  toolName: contentBlock.toolName,
-                  args: contentBlock.jsonText
-                });
-                delete toolCallContentBlocks[index];
+              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) {
+                  controller.enqueue({
+                    type: "tool-input-delta",
+                    id: contentBlock.toolCallId,
+                    delta
+                  });
+                }
+                contentBlock.jsonText += delta;
               }
             }
           },
@@ -873,129 +1172,134 @@ var BedrockChatLanguageModel = class {
     return `${this.config.baseUrl()}/model/${encodedModelId}`;
   }
 };
-var BedrockStopReasonSchema = import_zod3.z.union([
-  import_zod3.z.enum(BEDROCK_STOP_REASONS),
-  import_zod3.z.string()
+var BedrockStopReasonSchema = import_v43.z.union([
+  import_v43.z.enum(BEDROCK_STOP_REASONS),
+  import_v43.z.string()
 ]);
-var BedrockToolUseSchema = import_zod3.z.object({
-  toolUseId: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  input: import_zod3.z.unknown()
+var BedrockToolUseSchema = import_v43.z.object({
+  toolUseId: import_v43.z.string(),
+  name: import_v43.z.string(),
+  input: import_v43.z.unknown()
 });
-var BedrockReasoningTextSchema = import_zod3.z.object({
-  signature: import_zod3.z.string().nullish(),
-  text: import_zod3.z.string()
+var BedrockReasoningTextSchema = import_v43.z.object({
+  signature: import_v43.z.string().nullish(),
+  text: import_v43.z.string()
 });
-var BedrockRedactedReasoningSchema = import_zod3.z.object({
-  data: import_zod3.z.string()
+var BedrockRedactedReasoningSchema = import_v43.z.object({
+  data: import_v43.z.string()
 });
-var BedrockResponseSchema = import_zod3.z.object({
-  metrics: import_zod3.z.object({
-    latencyMs: import_zod3.z.number()
+var BedrockResponseSchema = import_v43.z.object({
+  metrics: import_v43.z.object({
+    latencyMs: import_v43.z.number()
   }).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(),
+  output: import_v43.z.object({
+    message: import_v43.z.object({
+      content: import_v43.z.array(
+        import_v43.z.object({
+          text: import_v43.z.string().nullish(),
           toolUse: BedrockToolUseSchema.nullish(),
-          reasoningContent: import_zod3.z.union([
-            import_zod3.z.object({
+          reasoningContent: import_v43.z.union([
+            import_v43.z.object({
               reasoningText: BedrockReasoningTextSchema
             }),
-            import_zod3.z.object({
+            import_v43.z.object({
               redactedReasoning: BedrockRedactedReasoningSchema
             })
           ]).nullish()
         })
       ),
-      role: import_zod3.z.string()
+      role: import_v43.z.string()
     })
   }),
   stopReason: BedrockStopReasonSchema,
-  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()
+  trace: import_v43.z.unknown().nullish(),
+  usage: import_v43.z.object({
+    inputTokens: import_v43.z.number(),
+    outputTokens: import_v43.z.number(),
+    totalTokens: import_v43.z.number(),
+    cacheReadInputTokens: import_v43.z.number().nullish(),
+    cacheWriteInputTokens: import_v43.z.number().nullish()
   })
 });
-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() })
+var BedrockStreamSchema = import_v43.z.object({
+  contentBlockDelta: import_v43.z.object({
+    contentBlockIndex: import_v43.z.number(),
+    delta: import_v43.z.union([
+      import_v43.z.object({ text: import_v43.z.string() }),
+      import_v43.z.object({ toolUse: import_v43.z.object({ input: import_v43.z.string() }) }),
+      import_v43.z.object({
+        reasoningContent: import_v43.z.object({ text: import_v43.z.string() })
       }),
-      import_zod3.z.object({
-        reasoningContent: import_zod3.z.object({
-          signature: import_zod3.z.string()
+      import_v43.z.object({
+        reasoningContent: import_v43.z.object({
+          signature: import_v43.z.string()
         })
       }),
-      import_zod3.z.object({
-        reasoningContent: import_zod3.z.object({ data: import_zod3.z.string() })
+      import_v43.z.object({
+        reasoningContent: import_v43.z.object({ data: import_v43.z.string() })
       })
     ]).nullish()
   }).nullish(),
-  contentBlockStart: import_zod3.z.object({
-    contentBlockIndex: import_zod3.z.number(),
-    start: import_zod3.z.object({
+  contentBlockStart: import_v43.z.object({
+    contentBlockIndex: import_v43.z.number(),
+    start: import_v43.z.object({
       toolUse: BedrockToolUseSchema.nullish()
     }).nullish()
   }).nullish(),
-  contentBlockStop: import_zod3.z.object({
-    contentBlockIndex: import_zod3.z.number()
+  contentBlockStop: import_v43.z.object({
+    contentBlockIndex: import_v43.z.number()
   }).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(),
+  internalServerException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
+  messageStop: import_v43.z.object({
+    additionalModelResponseFields: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
     stopReason: BedrockStopReasonSchema
   }).nullish(),
-  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()
+  metadata: import_v43.z.object({
+    trace: import_v43.z.unknown().nullish(),
+    usage: import_v43.z.object({
+      cacheReadInputTokens: import_v43.z.number().nullish(),
+      cacheWriteInputTokens: import_v43.z.number().nullish(),
+      inputTokens: import_v43.z.number(),
+      outputTokens: import_v43.z.number()
     }).nullish()
   }).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()
+  modelStreamErrorException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
+  throttlingException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish(),
+  validationException: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).nullish()
+});
+var bedrockReasoningMetadataSchema = import_v43.z.object({
+  signature: import_v43.z.string().optional(),
+  redactedData: import_v43.z.string().optional()
 });
 
 // src/bedrock-embedding-model.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_provider4 = require("@ai-sdk/provider");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
 // src/bedrock-embedding-options.ts
-var import_zod4 = require("zod");
-var bedrockEmbeddingProviderOptions = import_zod4.z.object({
+var import_v44 = require("zod/v4");
+var bedrockEmbeddingProviderOptions = import_v44.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(),
+  dimensions: import_v44.z.union([import_v44.z.literal(1024), import_v44.z.literal(512), import_v44.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()
+  normalize: import_v44.z.boolean().optional()
 });
 
 // src/bedrock-embedding-model.ts
-var import_zod5 = require("zod");
+var import_v45 = require("zod/v4");
 var BedrockEmbeddingModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
     this.specificationVersion = "v2";
     this.provider = "amazon-bedrock";
-    this.maxEmbeddingsPerCall = void 0;
+    this.maxEmbeddingsPerCall = 1;
     this.supportsParallelCalls = true;
   }
   getUrl(modelId) {
@@ -1009,57 +1313,54 @@ var BedrockEmbeddingModel = class {
     providerOptions
   }) {
     var _a;
-    const bedrockOptions = (_a = (0, import_provider_utils4.parseProviderOptions)({
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new import_provider4.TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const bedrockOptions = (_a = await (0, import_provider_utils5.parseProviderOptions)({
       provider: "bedrock",
       providerOptions,
       schema: bedrockEmbeddingProviderOptions
     })) != null ? _a : {};
-    const embedSingleText = async (inputText) => {
-      const args = {
-        inputText,
-        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 {
-        embedding: response.embedding,
-        inputTextTokenCount: response.inputTextTokenCount
-      };
+    const args = {
+      inputText: values[0],
+      dimensions: bedrockOptions.dimensions,
+      normalize: bedrockOptions.normalize
+    };
+    const url = this.getUrl(this.modelId);
+    const { value: response } = await (0, import_provider_utils5.postJsonToApi)({
+      url,
+      headers: await (0, import_provider_utils5.resolve)(
+        (0, import_provider_utils5.combineHeaders)(await (0, import_provider_utils5.resolve)(this.config.headers), headers)
+      ),
+      body: args,
+      failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
+        errorSchema: BedrockErrorSchema,
+        errorToMessage: (error) => `${error.type}: ${error.message}`
+      }),
+      successfulResponseHandler: (0, import_provider_utils5.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_zod5.z.object({
-  embedding: import_zod5.z.array(import_zod5.z.number()),
-  inputTextTokenCount: import_zod5.z.number()
+var BedrockEmbeddingResponseSchema = import_v45.z.object({
+  embedding: import_v45.z.array(import_v45.z.number()),
+  inputTextTokenCount: import_v45.z.number()
 });
 
 // src/bedrock-image-model.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
 
 // src/bedrock-image-settings.ts
 var modelMaxImagesPerCall = {
@@ -1067,18 +1368,17 @@ var modelMaxImagesPerCall = {
 };
 
 // src/bedrock-image-model.ts
-var import_zod6 = require("zod");
+var import_v46 = require("zod/v4");
 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);
@@ -1094,7 +1394,7 @@ var BedrockImageModel = class {
     headers,
     abortSignal
   }) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const warnings = [];
     const [width, height] = size ? size.split("x").map(Number) : [];
     const args = {
@@ -1103,6 +1403,9 @@ var BedrockImageModel = class {
         text: prompt,
         ...((_a = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _a.negativeText) ? {
           negativeText: providerOptions.bedrock.negativeText
+        } : {},
+        ...((_b = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _b.style) ? {
+          style: providerOptions.bedrock.style
         } : {}
       },
       imageGenerationConfig: {
@@ -1110,8 +1413,8 @@ var BedrockImageModel = class {
         ...height ? { height } : {},
         ...seed ? { seed } : {},
         ...n ? { numberOfImages: n } : {},
-        ...((_b = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _b.quality) ? { quality: providerOptions.bedrock.quality } : {},
-        ...((_c = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _c.cfgScale) ? { cfgScale: providerOptions.bedrock.cfgScale } : {}
+        ...((_c = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _c.quality) ? { quality: providerOptions.bedrock.quality } : {},
+        ...((_d = providerOptions == null ? void 0 : providerOptions.bedrock) == null ? void 0 : _d.cfgScale) ? { cfgScale: providerOptions.bedrock.cfgScale } : {}
       }
     };
     if (aspectRatio != void 0) {
@@ -1121,18 +1424,18 @@ var BedrockImageModel = class {
         details: "This model does not support aspect ratio. Use `size` instead."
       });
     }
-    const currentDate = (_f = (_e = (_d = this.config._internal) == null ? void 0 : _d.currentDate) == null ? void 0 : _e.call(_d)) != null ? _f : /* @__PURE__ */ new Date();
-    const { value: response, responseHeaders } = await (0, import_provider_utils5.postJsonToApi)({
+    const currentDate = (_g = (_f = (_e = this.config._internal) == null ? void 0 : _e.currentDate) == null ? void 0 : _f.call(_e)) != null ? _g : /* @__PURE__ */ new Date();
+    const { value: response, responseHeaders } = await (0, import_provider_utils6.postJsonToApi)({
       url: this.getUrl(this.modelId),
-      headers: await (0, import_provider_utils5.resolve)(
-        (0, import_provider_utils5.combineHeaders)(await (0, import_provider_utils5.resolve)(this.config.headers), headers)
+      headers: await (0, import_provider_utils6.resolve)(
+        (0, import_provider_utils6.combineHeaders)(await (0, import_provider_utils6.resolve)(this.config.headers), headers)
       ),
       body: args,
-      failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
+      failedResponseHandler: (0, import_provider_utils6.createJsonErrorResponseHandler)({
         errorSchema: BedrockErrorSchema,
         errorToMessage: (error) => `${error.type}: ${error.message}`
       }),
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
         bedrockImageResponseSchema
       ),
       abortSignal,
@@ -1149,8 +1452,8 @@ var BedrockImageModel = class {
     };
   }
 };
-var bedrockImageResponseSchema = import_zod6.z.object({
-  images: import_zod6.z.array(import_zod6.z.string())
+var bedrockImageResponseSchema = import_v46.z.object({
+  images: import_v46.z.array(import_v46.z.string())
 });
 
 // src/headers-utils.ts
@@ -1172,15 +1475,11 @@ 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
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
 var import_aws4fetch = require("aws4fetch");
 function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
   return async (input, init) => {
@@ -1195,7 +1494,7 @@ function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
     const signer = new import_aws4fetch.AwsV4Signer({
       url,
       method: "POST",
-      headers: Object.entries((0, import_provider_utils6.removeUndefinedEntries)(originalHeaders)),
+      headers: Object.entries((0, import_provider_utils7.removeUndefinedEntries)(originalHeaders)),
       body,
       region: credentials.region,
       accessKeyId: credentials.accessKeyId,
@@ -1208,8 +1507,8 @@ function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
     return fetch(input, {
       ...init,
       body,
-      headers: (0, import_provider_utils6.removeUndefinedEntries)(
-        (0, import_provider_utils6.combineHeaders)(originalHeaders, signedHeaders)
+      headers: (0, import_provider_utils7.removeUndefinedEntries)(
+        (0, import_provider_utils7.combineHeaders)(originalHeaders, signedHeaders)
       )
     });
   };
@@ -1225,46 +1524,92 @@ function prepareBodyString(body) {
     return JSON.stringify(body);
   }
 }
+function createApiKeyFetchFunction(apiKey, fetch = globalThis.fetch) {
+  return async (input, init) => {
+    const originalHeaders = extractHeaders(init == null ? void 0 : init.headers);
+    return fetch(input, {
+      ...init,
+      headers: (0, import_provider_utils7.removeUndefinedEntries)(
+        (0, import_provider_utils7.combineHeaders)(originalHeaders, {
+          Authorization: `Bearer ${apiKey}`
+        })
+      )
+    });
+  };
+}
 
 // src/bedrock-provider.ts
 function createAmazonBedrock(options = {}) {
-  const sigv4Fetch = createSigV4FetchFunction(async () => {
-    const region = (0, import_provider_utils7.loadSetting)({
+  const rawApiKey = (0, import_provider_utils8.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)({
       settingValue: options.region,
       settingName: "region",
       environmentVariableName: "AWS_REGION",
       description: "AWS region"
     });
     if (options.credentialProvider) {
+      try {
+        return {
+          ...await options.credentialProvider(),
+          region
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `AWS credential provider failed: ${errorMessage}. Please ensure your credential provider returns valid AWS credentials with accessKeyId and secretAccessKey properties.`
+        );
+      }
+    }
+    try {
       return {
-        ...await options.credentialProvider(),
-        region
+        region,
+        accessKeyId: (0, import_provider_utils8.loadSetting)({
+          settingValue: options.accessKeyId,
+          settingName: "accessKeyId",
+          environmentVariableName: "AWS_ACCESS_KEY_ID",
+          description: "AWS access key ID"
+        }),
+        secretAccessKey: (0, import_provider_utils8.loadSetting)({
+          settingValue: options.secretAccessKey,
+          settingName: "secretAccessKey",
+          environmentVariableName: "AWS_SECRET_ACCESS_KEY",
+          description: "AWS secret access key"
+        }),
+        sessionToken: (0, import_provider_utils8.loadOptionalSetting)({
+          settingValue: options.sessionToken,
+          environmentVariableName: "AWS_SESSION_TOKEN"
+        })
       };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("AWS_ACCESS_KEY_ID") || errorMessage.includes("accessKeyId")) {
+        throw new Error(
+          `AWS SigV4 authentication requires AWS credentials. Please provide either:
+1. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables
+2. Provide accessKeyId and secretAccessKey in options
+3. Use a credentialProvider function
+4. Use API key authentication with AWS_BEARER_TOKEN_BEDROCK or apiKey option
+Original error: ${errorMessage}`
+        );
+      }
+      if (errorMessage.includes("AWS_SECRET_ACCESS_KEY") || errorMessage.includes("secretAccessKey")) {
+        throw new Error(
+          `AWS SigV4 authentication requires both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY. Please ensure both credentials are provided.
+Original error: ${errorMessage}`
+        );
+      }
+      throw error;
     }
-    return {
-      region,
-      accessKeyId: (0, import_provider_utils7.loadSetting)({
-        settingValue: options.accessKeyId,
-        settingName: "accessKeyId",
-        environmentVariableName: "AWS_ACCESS_KEY_ID",
-        description: "AWS access key ID"
-      }),
-      secretAccessKey: (0, import_provider_utils7.loadSetting)({
-        settingValue: options.secretAccessKey,
-        settingName: "secretAccessKey",
-        environmentVariableName: "AWS_SECRET_ACCESS_KEY",
-        description: "AWS secret access key"
-      }),
-      sessionToken: (0, import_provider_utils7.loadOptionalSetting)({
-        settingValue: options.sessionToken,
-        environmentVariableName: "AWS_SESSION_TOKEN"
-      })
-    };
   }, options.fetch);
   const getBaseUrl = () => {
     var _a, _b;
-    return (_b = (0, import_provider_utils7.withoutTrailingSlash)(
-      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${(0, import_provider_utils7.loadSetting)({
+    return (_b = (0, import_provider_utils8.withoutTrailingSlash)(
+      (_a = options.baseURL) != null ? _a : `https://bedrock-runtime.${(0, import_provider_utils8.loadSetting)({
         settingValue: options.region,
         settingName: "region",
         environmentVariableName: "AWS_REGION",
@@ -1277,8 +1622,8 @@ function createAmazonBedrock(options = {}) {
     return new BedrockChatLanguageModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
-      fetch: sigv4Fetch,
-      generateId: import_provider_utils7.generateId
+      fetch: fetchFunction,
+      generateId: import_provider_utils8.generateId
     });
   };
   const provider = function(modelId) {
@@ -1294,15 +1639,15 @@ function createAmazonBedrock(options = {}) {
     return new BedrockEmbeddingModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
-      fetch: sigv4Fetch
+      fetch: fetchFunction
     });
   };
-  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
+      fetch: fetchFunction
     });
   };
   provider.languageModel = createChatModel;
@@ -1311,6 +1656,7 @@ function createAmazonBedrock(options = {}) {
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.image = createImageModel;
   provider.imageModel = createImageModel;
+  provider.tools = import_internal2.anthropicTools;
   return provider;
 }
 var bedrock = createAmazonBedrock();