@ai-sdk/amazon-bedrock 2.0.5 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/amazon-bedrock
 
+## 2.1.0
+
+### Minor Changes
+
+- cf7d818: feat (providers/amazon-bedrock): Add reasoning support to amazon-bedrock
+
+## 2.0.6
+
+### Patch Changes
+
+- Updated dependencies [e1d3d42]
+  - @ai-sdk/provider@1.0.10
+  - @ai-sdk/provider-utils@2.1.11
+
 ## 2.0.5
 
 ### Patch Changes

package/dist/index.js

@@ -326,11 +326,45 @@ function convertToBedrockChatMessages(prompt) {
                     // 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
-                    isLastBlock && isLastMessage && isLastContentPart ? part.text.trim() : part.text
+                    trimIfLast(
+                      isLastBlock,
+                      isLastMessage,
+                      isLastContentPart,
+                      part.text
+                    )
                   )
                 });
                 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
+                    }
+                  }
+                });
+                break;
+              }
+              case "redacted-reasoning": {
+                bedrockContent.push({
+                  reasoningContent: {
+                    redactedReasoning: {
+                      data: part.data
+                    }
+                  }
+                });
+                break;
+              }
               case "tool-call": {
                 bedrockContent.push({
                   toolUse: {
@@ -358,6 +392,9 @@ function convertToBedrockChatMessages(prompt) {
   }
   return { system, messages };
 }
+function trimIfLast(isLastBlock, isLastMessage, isLastContentPart, text) {
+  return isLastBlock && isLastMessage && isLastContentPart ? text.trim() : text;
+}
 function groupIntoBlocks(prompt) {
   const blocks = [];
   let currentBlock = void 0;
@@ -450,7 +487,7 @@ var BedrockChatLanguageModel = class {
     providerMetadata,
     headers
   }) {
-    var _a;
+    var _a, _b, _c, _d;
     const type = mode.type;
     const warnings = [];
     if (frequencyPenalty != null) {
@@ -485,12 +522,51 @@ var BedrockChatLanguageModel = class {
       });
     }
     const { system, messages } = convertToBedrockChatMessages(prompt);
+    const reasoningConfigOptions = BedrockReasoningConfigOptionsSchema.safeParse(
+      (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.reasoning_config
+    );
+    if (!reasoningConfigOptions.success) {
+      throw new import_provider4.InvalidArgumentError({
+        argument: "providerOptions.bedrock.reasoning_config",
+        message: "invalid reasoning configuration options",
+        cause: reasoningConfigOptions.error
+      });
+    }
+    const isThinking = ((_b = reasoningConfigOptions.data) == null ? void 0 : _b.type) === "enabled";
+    const thinkingBudget = (_c = reasoningConfigOptions.data) == null ? void 0 : _c.budget_tokens;
     const inferenceConfig = {
       ...maxTokens != null && { maxTokens },
       ...temperature != null && { temperature },
       ...topP != null && { topP },
       ...stopSequences != null && { stopSequences }
     };
+    if (isThinking && thinkingBudget != null) {
+      if (inferenceConfig.maxTokens != null) {
+        inferenceConfig.maxTokens += thinkingBudget;
+      } else {
+        inferenceConfig.maxTokens = thinkingBudget + 4096;
+      }
+      this.settings.additionalModelRequestFields = {
+        ...this.settings.additionalModelRequestFields,
+        reasoning_config: { ...reasoningConfigOptions.data }
+      };
+    }
+    if (isThinking && inferenceConfig.temperature != null) {
+      delete inferenceConfig.temperature;
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "temperature",
+        details: "temperature is not supported when thinking is enabled"
+      });
+    }
+    if (isThinking && inferenceConfig.topP != null) {
+      delete inferenceConfig.topP;
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topP",
+        details: "topP is not supported when thinking is enabled"
+      });
+    }
     const baseArgs = {
       system,
       additionalModelRequestFields: this.settings.additionalModelRequestFields,
@@ -506,7 +582,7 @@ var BedrockChatLanguageModel = class {
         return {
           command: {
             ...baseArgs,
-            ...((_a = toolConfig.tools) == null ? void 0 : _a.length) ? { toolConfig } : {}
+            ...((_d = toolConfig.tools) == null ? void 0 : _d.length) ? { toolConfig } : {}
           },
           warnings: [...warnings, ...toolWarnings]
         };
@@ -580,6 +656,25 @@ var BedrockChatLanguageModel = class {
         }
       }
     } : void 0;
+    const reasoning = response.output.message.content.filter((content) => content.reasoningContent).map((content) => {
+      var _a2;
+      if (content.reasoningContent && "reasoningText" in content.reasoningContent) {
+        return {
+          type: "text",
+          text: content.reasoningContent.reasoningText.text,
+          ...content.reasoningContent.reasoningText.signature && {
+            signature: content.reasoningContent.reasoningText.signature
+          }
+        };
+      } else if (content.reasoningContent && "redactedReasoning" in content.reasoningContent) {
+        return {
+          type: "redacted",
+          data: (_a2 = content.reasoningContent.redactedReasoning.data) != null ? _a2 : ""
+        };
+      } else {
+        return void 0;
+      }
+    }).filter((item) => item !== void 0);
     return {
       text: (_h = (_g = (_f = (_e = response.output) == null ? void 0 : _e.message) == null ? void 0 : _f.content) == null ? void 0 : _g.map((part) => {
         var _a2;
@@ -604,6 +699,7 @@ var BedrockChatLanguageModel = class {
       rawCall: { rawPrompt, rawSettings },
       rawResponse: { headers: responseHeaders },
       warnings,
+      reasoning: reasoning.length > 0 ? reasoning : void 0,
       ...providerMetadata && { providerMetadata }
     };
   }
@@ -637,7 +733,7 @@ var BedrockChatLanguageModel = class {
       stream: response.pipeThrough(
         new TransformStream({
           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;
             function enqueueError(bedrockError) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: bedrockError });
@@ -697,8 +793,27 @@ var BedrockChatLanguageModel = class {
                 textDelta: value.contentBlockDelta.delta.text
               });
             }
+            if (((_l = value.contentBlockDelta) == null ? void 0 : _l.delta) && "reasoningContent" in value.contentBlockDelta.delta && value.contentBlockDelta.delta.reasoningContent) {
+              const reasoningContent = value.contentBlockDelta.delta.reasoningContent;
+              if ("text" in reasoningContent && reasoningContent.text) {
+                controller.enqueue({
+                  type: "reasoning",
+                  textDelta: reasoningContent.text
+                });
+              } else if ("signature" in reasoningContent && reasoningContent.signature) {
+                controller.enqueue({
+                  type: "reasoning-signature",
+                  signature: reasoningContent.signature
+                });
+              } else if ("data" in reasoningContent && reasoningContent.data) {
+                controller.enqueue({
+                  type: "redacted-reasoning",
+                  data: reasoningContent.data
+                });
+              }
+            }
             const contentBlockStart = value.contentBlockStart;
-            if (((_l = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _l.toolUse) != null) {
+            if (((_m = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _m.toolUse) != null) {
               const toolUse = contentBlockStart.start.toolUse;
               toolCallContentBlocks[contentBlockStart.contentBlockIndex] = {
                 toolCallId: toolUse.toolUseId,
@@ -709,7 +824,7 @@ var BedrockChatLanguageModel = class {
             const contentBlockDelta = value.contentBlockDelta;
             if ((contentBlockDelta == null ? void 0 : contentBlockDelta.delta) && "toolUse" in contentBlockDelta.delta && contentBlockDelta.delta.toolUse) {
               const contentBlock = toolCallContentBlocks[contentBlockDelta.contentBlockIndex];
-              const delta = (_m = contentBlockDelta.delta.toolUse.input) != null ? _m : "";
+              const delta = (_n = contentBlockDelta.delta.toolUse.input) != null ? _n : "";
               controller.enqueue({
                 type: "tool-call-delta",
                 toolCallType: "function",
@@ -755,6 +870,10 @@ var BedrockChatLanguageModel = class {
     return `${this.config.baseUrl()}/model/${encodedModelId}`;
   }
 };
+var BedrockReasoningConfigOptionsSchema = import_zod2.z.object({
+  type: import_zod2.z.union([import_zod2.z.literal("enabled"), import_zod2.z.literal("disabled")]),
+  budget_tokens: import_zod2.z.number().nullish()
+}).nullish();
 var BedrockStopReasonSchema = import_zod2.z.union([
   import_zod2.z.enum(BEDROCK_STOP_REASONS),
   import_zod2.z.string()
@@ -764,6 +883,13 @@ var BedrockToolUseSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
   input: import_zod2.z.unknown()
 });
+var BedrockReasoningTextSchema = import_zod2.z.object({
+  signature: import_zod2.z.string().nullish(),
+  text: import_zod2.z.string()
+});
+var BedrockRedactedReasoningSchema = import_zod2.z.object({
+  data: import_zod2.z.string()
+});
 var BedrockResponseSchema = import_zod2.z.object({
   metrics: import_zod2.z.object({
     latencyMs: import_zod2.z.number()
@@ -773,7 +899,15 @@ var BedrockResponseSchema = import_zod2.z.object({
       content: import_zod2.z.array(
         import_zod2.z.object({
           text: import_zod2.z.string().nullish(),
-          toolUse: BedrockToolUseSchema.nullish()
+          toolUse: BedrockToolUseSchema.nullish(),
+          reasoningContent: import_zod2.z.union([
+            import_zod2.z.object({
+              reasoningText: BedrockReasoningTextSchema
+            }),
+            import_zod2.z.object({
+              redactedReasoning: BedrockRedactedReasoningSchema
+            })
+          ]).nullish()
         })
       ),
       role: import_zod2.z.string()
@@ -794,7 +928,18 @@ var BedrockStreamSchema = import_zod2.z.object({
     contentBlockIndex: import_zod2.z.number(),
     delta: import_zod2.z.union([
       import_zod2.z.object({ text: import_zod2.z.string() }),
-      import_zod2.z.object({ toolUse: import_zod2.z.object({ input: import_zod2.z.string() }) })
+      import_zod2.z.object({ toolUse: import_zod2.z.object({ input: import_zod2.z.string() }) }),
+      import_zod2.z.object({
+        reasoningContent: import_zod2.z.object({ text: import_zod2.z.string() })
+      }),
+      import_zod2.z.object({
+        reasoningContent: import_zod2.z.object({
+          signature: import_zod2.z.string()
+        })
+      }),
+      import_zod2.z.object({
+        reasoningContent: import_zod2.z.object({ data: import_zod2.z.string() })
+      })
     ]).nullish()
   }).nullish(),
   contentBlockStart: import_zod2.z.object({