@ai-sdk/amazon-bedrock 4.0.161 → 4.0.165

package/dist/mantle/index.js

@@ -35,7 +35,7 @@ var import_provider_utils = require("@ai-sdk/provider-utils");
 var import_aws4fetch = require("aws4fetch");
 
 // src/version.ts
-var VERSION = true ? "4.0.161" : "0.0.0-test";
+var VERSION = true ? "4.0.165" : "0.0.0-test";
 
 // src/bedrock-sigv4-fetch.ts
 function createSigV4FetchFunction(getCredentials, fetch, service = "bedrock") {

package/dist/mantle/index.mjs

@@ -23,7 +23,7 @@ import {
 import { AwsV4Signer } from "aws4fetch";
 
 // src/version.ts
-var VERSION = true ? "4.0.161" : "0.0.0-test";
+var VERSION = true ? "4.0.165" : "0.0.0-test";
 
 // src/bedrock-sigv4-fetch.ts
 function createSigV4FetchFunction(getCredentials, fetch, service = "bedrock") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/amazon-bedrock",
-  "version": "4.0.161",
+  "version": "4.0.165",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -44,10 +44,10 @@
     "@smithy/eventstream-codec": "^4.0.1",
     "@smithy/util-utf8": "^4.0.0",
     "aws4fetch": "^1.0.20",
-    "@ai-sdk/anthropic": "3.0.113",
-    "@ai-sdk/openai": "3.0.101",
+    "@ai-sdk/anthropic": "3.0.114",
+    "@ai-sdk/openai": "3.0.104",
     "@ai-sdk/provider": "3.0.15",
-    "@ai-sdk/provider-utils": "4.0.48"
+    "@ai-sdk/provider-utils": "4.0.49"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/bedrock-chat-language-model.ts

@@ -61,6 +61,10 @@ type BedrockChatConfig = {
   generateId: () => string;
 };
 
+const anthropicProviderOptions = z.object({
+  disableParallelToolUse: z.boolean().optional(),
+});
+
 export class BedrockChatLanguageModel implements LanguageModelV3 {
   readonly specificationVersion = 'v3';
   readonly provider = 'amazon-bedrock';
@@ -99,6 +103,12 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
         schema: amazonBedrockLanguageModelOptions,
       })) ?? {};
 
+    const anthropicOptions = await parseProviderOptions({
+      provider: 'anthropic',
+      providerOptions,
+      schema: anthropicProviderOptions,
+    });
+
     const warnings: SharedV3Warning[] = [];
 
     if (frequencyPenalty != null) {
@@ -151,6 +161,10 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
     }
 
     const isAnthropicModel = this.modelId.includes('anthropic');
+    const openAIModelId = /^(?:[^.]+\.)?(openai\..+)$/.exec(this.modelId)?.[1];
+    const isOpenAIModel = openAIModelId != null;
+    const isOpenAIGptOssModel =
+      openAIModelId?.startsWith('openai.gpt-oss-') ?? false;
     const isThinkingEnabled =
       bedrockOptions.reasoningConfig?.type === 'enabled' ||
       bedrockOptions.reasoningConfig?.type === 'adaptive';
@@ -192,6 +206,7 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
         toolChoice:
           jsonResponseTool != null ? { type: 'required' } : toolChoice,
         modelId: this.modelId,
+        disableParallelToolUse: anthropicOptions?.disableParallelToolUse,
       });
 
     warnings.push(...toolWarnings);
@@ -279,7 +294,6 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
 
     const maxReasoningEffort =
       bedrockOptions.reasoningConfig?.maxReasoningEffort;
-    const isOpenAIModel = this.modelId.startsWith('openai.');
 
     if (maxReasoningEffort != null) {
       if (isAnthropicModel) {
@@ -291,11 +305,20 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
           },
         };
       } else if (isOpenAIModel) {
-        // OpenAI models on Bedrock expect `reasoning_effort` as a flat value
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
-          reasoning_effort: maxReasoningEffort,
-        };
+        // gpt-oss models expect `reasoning_effort` as a flat value, while
+        // GPT-5.x models expect a nested `reasoning.effort` object.
+        bedrockOptions.additionalModelRequestFields = isOpenAIGptOssModel
+          ? {
+              ...bedrockOptions.additionalModelRequestFields,
+              reasoning_effort: maxReasoningEffort,
+            }
+          : {
+              ...bedrockOptions.additionalModelRequestFields,
+              reasoning: {
+                ...bedrockOptions.additionalModelRequestFields?.reasoning,
+                effort: maxReasoningEffort,
+              },
+            };
       } else {
         // other models (such as Nova 2) use reasoningConfig format
         bedrockOptions.additionalModelRequestFields = {
@@ -1185,6 +1208,13 @@ const BedrockRedactedReasoningSchema = z.object({
   data: z.string(),
 });
 
+const AmazonBedrockCacheDetailSchema = z
+  .object({
+    inputTokens: z.number(),
+    ttl: z.string(),
+  })
+  .catchall(z.json());
+
 // limited version of the schema, focused on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
 const BedrockResponseSchema = z.object({
@@ -1227,16 +1257,16 @@ const BedrockResponseSchema = z.object({
   trace: z.unknown().nullish(),
   performanceConfig: z.object({ latency: z.string() }).nullish(),
   serviceTier: z.object({ type: z.string() }).nullish(),
-  usage: z.object({
-    inputTokens: z.number(),
-    outputTokens: z.number(),
-    totalTokens: z.number(),
-    cacheReadInputTokens: z.number().nullish(),
-    cacheWriteInputTokens: z.number().nullish(),
-    cacheDetails: z
-      .array(z.object({ inputTokens: z.number(), ttl: z.string() }))
-      .nullish(),
-  }),
+  usage: z
+    .object({
+      inputTokens: z.number(),
+      outputTokens: z.number(),
+      totalTokens: z.number(),
+      cacheReadInputTokens: z.number().nullish(),
+      cacheWriteInputTokens: z.number().nullish(),
+      cacheDetails: z.array(AmazonBedrockCacheDetailSchema).nullish(),
+    })
+    .catchall(z.json()),
 });
 
 // limited version of the schema, focussed on what is needed for the implementation
@@ -1302,12 +1332,12 @@ const BedrockStreamSchema = z.object({
         .object({
           cacheReadInputTokens: z.number().nullish(),
           cacheWriteInputTokens: z.number().nullish(),
-          cacheDetails: z
-            .array(z.object({ inputTokens: z.number(), ttl: z.string() }))
-            .nullish(),
+          cacheDetails: z.array(AmazonBedrockCacheDetailSchema).nullish(),
           inputTokens: z.number(),
           outputTokens: z.number(),
+          totalTokens: z.number().optional(),
         })
+        .catchall(z.json())
         .nullish(),
     })
     .nullish(),

package/src/bedrock-prepare-tools.ts

@@ -19,10 +19,12 @@ export async function prepareTools({
   tools,
   toolChoice,
   modelId,
+  disableParallelToolUse,
 }: {
   tools: LanguageModelV3CallOptions['tools'];
   toolChoice?: LanguageModelV3CallOptions['toolChoice'];
   modelId: string;
+  disableParallelToolUse?: boolean;
 }): Promise<{
   toolConfig: BedrockToolConfiguration;
   additionalTools: Record<string, unknown> | undefined;
@@ -85,6 +87,7 @@ export async function prepareTools({
     } = await prepareAnthropicTools({
       tools: ProviderTools,
       toolChoice,
+      disableParallelToolUse,
       supportsStructuredOutput: false,
       supportsStrictTools: false,
     });
@@ -161,9 +164,35 @@ export async function prepareTools({
     });
   }
 
+  if (
+    isAnthropicModel &&
+    !usingAnthropicTools &&
+    disableParallelToolUse &&
+    bedrockTools.length > 0 &&
+    toolChoice?.type !== 'none'
+  ) {
+    additionalTools = {
+      tool_choice:
+        toolChoice?.type === 'required'
+          ? { type: 'any', disable_parallel_tool_use: true }
+          : toolChoice?.type === 'tool'
+            ? {
+                type: 'tool',
+                name: toolChoice.toolName,
+                disable_parallel_tool_use: true,
+              }
+            : { type: 'auto', disable_parallel_tool_use: true },
+    };
+  }
+
   // Handle toolChoice for standard Bedrock tools, but NOT for Anthropic provider-defined tools
   let bedrockToolChoice: BedrockToolConfiguration['toolChoice'] = undefined;
-  if (!usingAnthropicTools && bedrockTools.length > 0 && toolChoice) {
+  if (
+    !usingAnthropicTools &&
+    additionalTools?.tool_choice == null &&
+    bedrockTools.length > 0 &&
+    toolChoice
+  ) {
     const type = toolChoice.type;
     switch (type) {
       case 'auto':

package/src/convert-bedrock-usage.ts

@@ -1,11 +1,17 @@
-import type { LanguageModelV3Usage } from '@ai-sdk/provider';
+import type { JSONValue, LanguageModelV3Usage } from '@ai-sdk/provider';
 
 export type BedrockUsage = {
+  [key: string]: JSONValue | undefined;
   inputTokens: number;
   outputTokens: number;
   totalTokens?: number;
   cacheReadInputTokens?: number | null;
   cacheWriteInputTokens?: number | null;
+  cacheDetails?: Array<{
+    [key: string]: JSONValue | undefined;
+    inputTokens: number;
+    ttl: string;
+  }> | null;
 };
 
 export function convertBedrockUsage(

package/src/convert-to-bedrock-chat-messages.ts

@@ -334,7 +334,12 @@ export async function convertToBedrockChatMessages(
           pushCachePoint(bedrockContent, providerOptions);
         }
 
-        messages.push({ role: 'user', content: bedrockContent });
+        const previousMessage = messages.at(-1);
+        if (previousMessage?.role === 'user') {
+          previousMessage.content.push(...bedrockContent);
+        } else {
+          messages.push({ role: 'user', content: bedrockContent });
+        }
 
         break;
       }
@@ -347,8 +352,56 @@ export async function convertToBedrockChatMessages(
           const message = block.messages[j];
           const isLastMessage = j === block.messages.length - 1;
           const { content } = message;
-          const hasReasoningBlocks = content.some(
-            part => part.type === 'reasoning',
+          const convertedReasoningContent: Array<
+            BedrockAssistantMessage['content'][number] | undefined
+          > = await Promise.all(
+            content.map(async part => {
+              if (part.type !== 'reasoning') {
+                return undefined;
+              }
+
+              const metadata = await parseProviderOptions({
+                provider: 'bedrock',
+                providerOptions: part.providerOptions,
+                schema: bedrockReasoningMetadataSchema,
+              });
+
+              if (metadata?.signature != null) {
+                return {
+                  reasoningContent: {
+                    reasoningText: {
+                      // do not trim reasoning text when a signature is present:
+                      // the signature validates the exact original bytes
+                      text: part.text,
+                      signature: metadata.signature,
+                    },
+                  },
+                };
+              }
+
+              if (metadata?.redactedContent != null) {
+                return {
+                  reasoningContent: {
+                    redactedContent: metadata.redactedContent,
+                  },
+                };
+              }
+
+              if (metadata?.redactedData != null) {
+                return {
+                  reasoningContent: {
+                    redactedReasoning: {
+                      data: metadata.redactedData,
+                    },
+                  },
+                };
+              }
+
+              return undefined;
+            }),
+          );
+          const hasReplayableReasoningBlocks = convertedReasoningContent.some(
+            part => part != null,
           );
 
           for (let k = 0; k < content.length; k++) {
@@ -357,8 +410,9 @@ export async function convertToBedrockChatMessages(
 
             switch (part.type) {
               case 'text': {
-                // Skip empty text blocks unless reasoning blocks are present
-                if (!part.text.trim() && !hasReasoningBlocks) {
+                // Skip empty text blocks unless replayable reasoning blocks are
+                // present and the original block order must be preserved.
+                if (!part.text.trim() && !hasReplayableReasoningBlocks) {
                   break;
                 }
 
@@ -378,37 +432,9 @@ export async function convertToBedrockChatMessages(
               }
 
               case 'reasoning': {
-                const reasoningMetadata = await parseProviderOptions({
-                  provider: 'bedrock',
-                  providerOptions: part.providerOptions,
-                  schema: bedrockReasoningMetadataSchema,
-                });
-
-                if (reasoningMetadata?.signature != null) {
-                  // do not trim reasoning text when a signature is present:
-                  // the signature validates the exact original bytes
-                  bedrockContent.push({
-                    reasoningContent: {
-                      reasoningText: {
-                        text: part.text,
-                        signature: reasoningMetadata.signature,
-                      },
-                    },
-                  });
-                } else if (reasoningMetadata?.redactedContent != null) {
-                  bedrockContent.push({
-                    reasoningContent: {
-                      redactedContent: reasoningMetadata.redactedContent,
-                    },
-                  });
-                } else if (reasoningMetadata?.redactedData != null) {
-                  bedrockContent.push({
-                    reasoningContent: {
-                      redactedReasoning: {
-                        data: reasoningMetadata.redactedData,
-                      },
-                    },
-                  });
+                const convertedPart = convertedReasoningContent[k];
+                if (convertedPart != null) {
+                  bedrockContent.push(convertedPart);
                 }
                 // Unsigned reasoning is intentionally not replayed. Some
                 // Bedrock models (for example OpenAI gpt-oss) return reasoning
@@ -434,7 +460,9 @@ export async function convertToBedrockChatMessages(
           pushCachePoint(bedrockContent, message.providerOptions);
         }
 
-        messages.push({ role: 'assistant', content: bedrockContent });
+        if (bedrockContent.length > 0) {
+          messages.push({ role: 'assistant', content: bedrockContent });
+        }
 
         break;
       }