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

package/dist/index.js

@@ -30,7 +30,7 @@ var import_provider_utils7 = require("@ai-sdk/provider-utils");
 
 // src/bedrock-chat-language-model.ts
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_v43 = require("zod/v4");
 
 // src/bedrock-api-types.ts
 var BEDROCK_CACHE_POINT = {
@@ -48,27 +48,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")]).optional(),
-    budgetTokens: import_zod.z.number().optional()
+  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
@@ -144,14 +161,29 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
 
 // src/bedrock-prepare-tools.ts
 var import_provider2 = require("@ai-sdk/provider");
+function promptContainsToolContent(prompt) {
+  return prompt.some((message) => {
+    if ("content" in message && Array.isArray(message.content)) {
+      return message.content.some(
+        (part) => part.type === "tool-call" || part.type === "tool-result"
+      );
+    }
+    return false;
+  });
+}
 function prepareTools({
   tools,
-  toolChoice
+  toolChoice,
+  prompt
 }) {
   tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const hasToolContent = promptContainsToolContent(prompt);
   if (tools == null) {
     return {
-      toolConfig: { tools: void 0, toolChoice: void 0 },
+      toolConfig: {
+        tools: hasToolContent ? [] : void 0,
+        toolChoice: void 0
+      },
       toolWarnings: []
     };
   }
@@ -166,7 +198,7 @@ function prepareTools({
           name: tool.name,
           description: tool.description,
           inputSchema: {
-            json: tool.parameters
+            json: tool.inputSchema
           }
         }
       });
@@ -192,7 +224,10 @@ function prepareTools({
       };
     case "none":
       return {
-        toolConfig: { tools: void 0, toolChoice: void 0 },
+        toolConfig: {
+          tools: hasToolContent ? [] : void 0,
+          toolChoice: void 0
+        },
         toolWarnings
       };
     case "tool":
@@ -215,16 +250,16 @@ function prepareTools({
 // 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 });
 function getCachePoint(providerMetadata) {
   var _a;
   return (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.cachePoint;
 }
 async function convertToBedrockChatMessages(prompt) {
-  var _a, _b, _c, _d;
   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,20 +301,23 @@ async 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,
+                          format: getBedrockImageFormat(part.mediaType),
                           source: { bytes: (0, import_provider_utils2.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(),
+                          format: getBedrockDocumentFormat(part.mediaType),
+                          name: generateDocumentName(),
                           source: { bytes: (0, import_provider_utils2.convertToBase64)(part.data) }
                         }
                       });
@@ -291,36 +329,46 @@ async 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,
@@ -409,7 +457,7 @@ async function convertToBedrockChatMessages(prompt) {
                   toolUse: {
                     toolUseId: part.toolCallId,
                     name: part.toolName,
-                    input: part.args
+                    input: part.input
                   }
                 });
                 break;
@@ -431,8 +479,31 @@ async 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;
@@ -528,7 +599,7 @@ var BedrockChatLanguageModel = class {
     toolChoice,
     providerOptions
   }) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     const bedrockOptions = (_a = await (0, import_provider_utils3.parseProviderOptions)({
       provider: "bedrock",
       providerOptions,
@@ -583,7 +654,7 @@ var BedrockChatLanguageModel = class {
       }
       bedrockOptions.additionalModelRequestFields = {
         ...bedrockOptions.additionalModelRequestFields,
-        reasoningConfig: {
+        thinking: {
           type: (_d = bedrockOptions.reasoningConfig) == null ? void 0 : _d.type,
           budget_tokens: thinkingBudget
         }
@@ -605,7 +676,12 @@ var BedrockChatLanguageModel = class {
         details: "topP is not supported when thinking is enabled"
       });
     }
-    const { toolConfig, toolWarnings } = prepareTools({ tools, toolChoice });
+    const { toolConfig, toolWarnings } = prepareTools({
+      tools,
+      toolChoice,
+      prompt
+    });
+    const { reasoningConfig: _, ...filteredBedrockOptions } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
     return {
       command: {
         system,
@@ -614,8 +690,8 @@ 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 } : {}
       },
       warnings: [...warnings, ...toolWarnings]
     };
@@ -678,10 +754,9 @@ var BedrockChatLanguageModel = class {
       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 : "")
+          input: JSON.stringify((_g = (_f = part.toolUse) == null ? void 0 : _f.input) != null ? _g : "")
         });
       }
     }
@@ -739,7 +814,7 @@ var BedrockChatLanguageModel = class {
       totalTokens: void 0
     };
     let providerMetadata = void 0;
-    const toolCallContentBlocks = {};
+    const contentBlocks = {};
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -747,11 +822,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;
+            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;
@@ -800,78 +878,126 @@ var BedrockChatLanguageModel = class {
                 };
               }
             }
-            if (((_j = value.contentBlockDelta) == null ? void 0 : _j.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 (((_k = value.contentBlockDelta) == null ? void 0 : _k.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" };
+                controller.enqueue({
+                  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) {
+              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") {
+                  controller.enqueue({
+                    type: "text-end",
+                    id: String(blockIndex)
+                  });
+                } else if (contentBlock.type === "tool-call") {
+                  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",
-                  text: reasoningContent.text
+                  type: "reasoning-delta",
+                  id: String(blockIndex),
+                  delta: reasoningContent.text
                 });
               } else if ("signature" in reasoningContent && reasoningContent.signature) {
                 controller.enqueue({
-                  type: "reasoning",
-                  text: "",
+                  type: "reasoning-delta",
+                  id: String(blockIndex),
+                  delta: "",
                   providerMetadata: {
                     bedrock: {
                       signature: reasoningContent.signature
                     }
                   }
                 });
-                controller.enqueue({ type: "reasoning-part-finish" });
               } else if ("data" in reasoningContent && reasoningContent.data) {
                 controller.enqueue({
-                  type: "reasoning",
-                  text: "",
+                  type: "reasoning-delta",
+                  id: String(blockIndex),
+                  delta: "",
                   providerMetadata: {
                     bedrock: {
                       redactedData: reasoningContent.data
                     }
                   }
                 });
-                controller.enqueue({ type: "reasoning-part-finish" });
               }
             }
             const contentBlockStart = value.contentBlockStart;
-            if (((_l = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _l.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: ""
               };
-            }
-            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 = (_m = contentBlockDelta.delta.toolUse.input) != null ? _m : "";
               controller.enqueue({
-                type: "tool-call-delta",
-                toolCallType: "function",
-                toolCallId: contentBlock.toolCallId,
-                toolName: contentBlock.toolName,
-                argsTextDelta: delta
+                type: "tool-input-start",
+                id: toolUse.toolUseId,
+                toolName: toolUse.name
               });
-              contentBlock.jsonText += delta;
             }
-            const contentBlockStop = value.contentBlockStop;
-            if (contentBlockStop != null) {
-              const index = contentBlockStop.contentBlockIndex;
-              const contentBlock = toolCallContentBlocks[index];
-              if (contentBlock != null) {
+            const contentBlockDelta = value.contentBlockDelta;
+            if ((contentBlockDelta == null ? void 0 : contentBlockDelta.delta) && "toolUse" in contentBlockDelta.delta && contentBlockDelta.delta.toolUse) {
+              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 : "";
                 controller.enqueue({
-                  type: "tool-call",
-                  toolCallType: "function",
-                  toolCallId: contentBlock.toolCallId,
-                  toolName: contentBlock.toolName,
-                  args: contentBlock.jsonText
+                  type: "tool-input-delta",
+                  id: contentBlock.toolCallId,
+                  delta
                 });
-                delete toolCallContentBlocks[index];
+                contentBlock.jsonText += delta;
               }
             }
           },
@@ -894,104 +1020,104 @@ 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_zod3.z.object({
-  signature: import_zod3.z.string().optional(),
-  redactedData: import_zod3.z.string().optional()
+var bedrockReasoningMetadataSchema = import_v43.z.object({
+  signature: import_v43.z.string().optional(),
+  redactedData: import_v43.z.string().optional()
 });
 
 // src/bedrock-embedding-model.ts
@@ -999,22 +1125,22 @@ var import_provider4 = require("@ai-sdk/provider");
 var import_provider_utils4 = 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;
@@ -1076,9 +1202,9 @@ var BedrockEmbeddingModel = class {
     };
   }
 };
-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
@@ -1090,7 +1216,7 @@ var modelMaxImagesPerCall = {
 };
 
 // src/bedrock-image-model.ts
-var import_zod6 = require("zod");
+var import_v46 = require("zod/v4");
 var BedrockImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1116,7 +1242,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 = {
@@ -1125,6 +1251,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: {
@@ -1132,8 +1261,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) {
@@ -1143,7 +1272,7 @@ 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 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_utils5.postJsonToApi)({
       url: this.getUrl(this.modelId),
       headers: await (0, import_provider_utils5.resolve)(
@@ -1171,8 +1300,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
@@ -1243,10 +1372,28 @@ 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_utils6.removeUndefinedEntries)(
+        (0, import_provider_utils6.combineHeaders)(originalHeaders, {
+          Authorization: `Bearer ${apiKey}`
+        })
+      )
+    });
+  };
+}
 
 // src/bedrock-provider.ts
 function createAmazonBedrock(options = {}) {
-  const sigv4Fetch = createSigV4FetchFunction(async () => {
+  const rawApiKey = (0, import_provider_utils7.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_utils7.loadSetting)({
       settingValue: options.region,
       settingName: "region",
@@ -1254,30 +1401,58 @@ function createAmazonBedrock(options = {}) {
       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_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"
+        })
       };
+    } 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;
@@ -1295,7 +1470,7 @@ function createAmazonBedrock(options = {}) {
     return new BedrockChatLanguageModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
-      fetch: sigv4Fetch,
+      fetch: fetchFunction,
       generateId: import_provider_utils7.generateId
     });
   };
@@ -1312,7 +1487,7 @@ function createAmazonBedrock(options = {}) {
     return new BedrockEmbeddingModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
-      fetch: sigv4Fetch
+      fetch: fetchFunction
     });
   };
   const createImageModel = (modelId) => {
@@ -1320,7 +1495,7 @@ function createAmazonBedrock(options = {}) {
     return new BedrockImageModel(modelId, {
       baseUrl: getBaseUrl,
       headers: (_a = options.headers) != null ? _a : {},
-      fetch: sigv4Fetch
+      fetch: fetchFunction
     });
   };
   provider.languageModel = createChatModel;