@ai-sdk/amazon-bedrock 5.0.58 → 5.0.60

package/dist/mantle/index.cjs

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

package/dist/mantle/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/amazon-bedrock",
-  "version": "5.0.58",
+  "version": "5.0.60",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -44,10 +44,10 @@
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",
     "aws4fetch": "^1.0.20",
-    "@ai-sdk/anthropic": "4.0.39",
-    "@ai-sdk/openai": "4.0.43",
+    "@ai-sdk/anthropic": "4.0.40",
+    "@ai-sdk/openai": "4.0.45",
     "@ai-sdk/provider": "4.0.7",
-    "@ai-sdk/provider-utils": "5.0.27"
+    "@ai-sdk/provider-utils": "5.0.28"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/amazon-bedrock-api-types.ts

@@ -258,6 +258,12 @@ export interface AmazonBedrockRedactedReasoningContentBlock {
   };
 }
 
+export interface AmazonBedrockRedactedContentBlock {
+  reasoningContent: {
+    redactedContent: string;
+  };
+}
+
 export type AmazonBedrockContentBlock =
   | AmazonBedrockDocumentBlock
   | AmazonBedrockGuardrailConverseContentBlock
@@ -268,4 +274,5 @@ export type AmazonBedrockContentBlock =
   | AmazonBedrockToolUseBlock
   | AmazonBedrockReasoningContentBlock
   | AmazonBedrockRedactedReasoningContentBlock
+  | AmazonBedrockRedactedContentBlock
   | AmazonBedrockCachePoint;

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

@@ -573,6 +573,18 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
               bedrock: redactedPayload,
             },
           });
+        } else if ('redactedContent' in part.reasoningContent) {
+          const redactedPayload: AmazonBedrockReasoningMetadata = {
+            redactedContent: part.reasoningContent.redactedContent,
+          };
+          content.push({
+            type: 'reasoning',
+            text: '',
+            providerMetadata: {
+              amazonBedrock: redactedPayload,
+              bedrock: redactedPayload,
+            },
+          });
         }
       }
 
@@ -591,7 +603,7 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
         } else {
           const isMistral = isMistralModel(this.modelId);
           const rawToolCallId =
-            part.toolUse?.toolUseId ?? this.config.generateId();
+            part.toolUse?.toolUseId || this.config.generateId();
           content.push({
             type: 'tool-call' as const,
             toolCallId: normalizeToolCallId(rawToolCallId, isMistral),
@@ -720,7 +732,8 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
           jsonText: string;
           isJsonResponseTool?: boolean;
         }
-      | { type: 'text' | 'reasoning' }
+      | { type: 'text' }
+      | { type: 'reasoning'; redactedContent?: string }
     > = {};
 
     return {
@@ -770,6 +783,10 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
               enqueueError(value.modelStreamErrorException);
               return;
             }
+            if (value.serviceUnavailableException) {
+              enqueueError(value.serviceUnavailableException);
+              return;
+            }
             if (value.throttlingException) {
               enqueueError(value.throttlingException);
               return;
@@ -891,9 +908,21 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
 
               if (contentBlock != null) {
                 if (contentBlock.type === 'reasoning') {
+                  const redactedPayload: AmazonBedrockReasoningMetadata | null =
+                    contentBlock.redactedContent != null
+                      ? { redactedContent: contentBlock.redactedContent }
+                      : null;
                   controller.enqueue({
                     type: 'reasoning-end',
                     id: String(blockIndex),
+                    ...(redactedPayload != null
+                      ? {
+                          providerMetadata: {
+                            amazonBedrock: redactedPayload,
+                            bedrock: redactedPayload,
+                          },
+                        }
+                      : {}),
                   });
                 } else if (contentBlock.type === 'text') {
                   controller.enqueue({
@@ -1008,6 +1037,27 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
                     },
                   });
                 }
+              } else if (
+                'redactedContent' in reasoningContent &&
+                reasoningContent.redactedContent
+              ) {
+                if (contentBlocks[blockIndex] == null) {
+                  contentBlocks[blockIndex] = { type: 'reasoning' };
+                  controller.enqueue({
+                    type: 'reasoning-start',
+                    id: String(blockIndex),
+                  });
+                }
+
+                const contentBlock = contentBlocks[blockIndex];
+                if (contentBlock.type === 'reasoning') {
+                  // accumulate and attach once via reasoning-end: the merged
+                  // provider metadata of a reasoning part is last-write-wins,
+                  // so per-delta metadata would drop earlier chunks
+                  contentBlock.redactedContent =
+                    (contentBlock.redactedContent ?? '') +
+                    reasoningContent.redactedContent;
+                }
               }
             }
 
@@ -1216,6 +1266,13 @@ const AmazonBedrockResponseSchema = z.object({
               z.object({
                 redactedReasoning: AmazonBedrockRedactedReasoningSchema,
               }),
+              // `redactedContent` is a member of the documented
+              // ReasoningContentBlock union. OpenAI models on Bedrock
+              // (e.g. `us.openai.gpt-5.6-luna`) return their encrypted
+              // reasoning in this shape.
+              z.object({
+                redactedContent: z.string(),
+              }),
             ])
             .nullish(),
         }),
@@ -1262,6 +1319,12 @@ const AmazonBedrockStreamSchema = z.object({
           z.object({
             reasoningContent: z.object({ data: z.string() }),
           }),
+          // `redactedContent` is a member of the documented
+          // ReasoningContentBlockDelta union. OpenAI models on Bedrock stream
+          // their encrypted reasoning in this shape.
+          z.object({
+            reasoningContent: z.object({ redactedContent: z.string() }),
+          }),
         ])
         .nullish(),
     })
@@ -1308,6 +1371,7 @@ const AmazonBedrockStreamSchema = z.object({
     })
     .nullish(),
   modelStreamErrorException: z.record(z.string(), z.unknown()).nullish(),
+  serviceUnavailableException: z.record(z.string(), z.unknown()).nullish(),
   throttlingException: z.record(z.string(), z.unknown()).nullish(),
   validationException: z.record(z.string(), z.unknown()).nullish(),
 });

package/src/amazon-bedrock-event-stream-decoder.ts

@@ -3,7 +3,8 @@ import { toUtf8, fromUtf8 } from '@smithy/util-utf8';
 
 export interface DecodedEvent {
   messageType: string;
-  eventType: string;
+  eventType?: string;
+  exceptionType?: string;
   data: string;
 }
 
@@ -43,10 +44,18 @@ export function createAmazonBedrockEventStreamDecoder<T>(
           buffer = buffer.slice(totalLength);
 
           const messageType = decoded.headers[':message-type']?.value as string;
-          const eventType = decoded.headers[':event-type']?.value as string;
+          const eventType = decoded.headers[':event-type']?.value as
+            | string
+            | undefined;
+          const exceptionType = decoded.headers[':exception-type']?.value as
+            | string
+            | undefined;
           const data = textDecoder.decode(decoded.body);
 
-          await processEvent({ messageType, eventType, data }, controller);
+          await processEvent(
+            { messageType, eventType, exceptionType, data },
+            controller,
+          );
         }
       },
       flush() {

package/src/amazon-bedrock-event-stream-response-handler.ts

@@ -25,31 +25,40 @@ export const createAmazonBedrockEventStreamResponseHandler =
       value: createAmazonBedrockEventStreamDecoder<ParseResult<T>>(
         response.body,
         async (event, controller) => {
-          if (event.messageType === 'event') {
-            const parsedDataResult = await safeParseJSON({ text: event.data });
-            if (!parsedDataResult.success) {
-              controller.enqueue(parsedDataResult);
-              return;
-            }
+          const payloadType =
+            event.messageType === 'event'
+              ? event.eventType
+              : event.messageType === 'exception'
+                ? event.exceptionType
+                : undefined;
 
-            delete (parsedDataResult.value as any).p;
-            const wrappedData = {
-              [event.eventType]: parsedDataResult.value,
-            };
+          if (payloadType == null) {
+            return;
+          }
+
+          const parsedDataResult = await safeParseJSON({ text: event.data });
+          if (!parsedDataResult.success) {
+            controller.enqueue(parsedDataResult);
+            return;
+          }
+
+          delete (parsedDataResult.value as any).p;
+          const wrappedData = {
+            [payloadType]: parsedDataResult.value,
+          };
 
-            const validatedWrappedData = await safeValidateTypes<T>({
-              value: wrappedData,
-              schema: chunkSchema,
+          const validatedWrappedData = await safeValidateTypes<T>({
+            value: wrappedData,
+            schema: chunkSchema,
+          });
+          if (!validatedWrappedData.success) {
+            controller.enqueue(validatedWrappedData);
+          } else {
+            controller.enqueue({
+              success: true,
+              value: validatedWrappedData.value,
+              rawValue: wrappedData,
             });
-            if (!validatedWrappedData.success) {
-              controller.enqueue(validatedWrappedData);
-            } else {
-              controller.enqueue({
-                success: true,
-                value: validatedWrappedData.value,
-                rawValue: wrappedData,
-              });
-            }
           }
         },
       ),

package/src/amazon-bedrock-reasoning-metadata.ts

@@ -3,6 +3,7 @@ import { z } from 'zod/v4';
 export const amazonBedrockReasoningMetadataSchema = z.object({
   signature: z.string().optional(),
   redactedData: z.string().optional(),
+  redactedContent: z.string().optional(),
 });
 
 export type AmazonBedrockReasoningMetadata = z.infer<

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

@@ -520,6 +520,12 @@ export async function convertToAmazonBedrockChatMessages(
                       },
                     },
                   });
+                } else if (reasoningMetadata?.redactedContent != null) {
+                  amazonBedrockContent.push({
+                    reasoningContent: {
+                      redactedContent: reasoningMetadata.redactedContent,
+                    },
+                  });
                 } else if (reasoningMetadata?.redactedData != null) {
                   amazonBedrockContent.push({
                     reasoningContent: {