@ai-sdk/amazon-bedrock 4.0.157 → 4.0.159

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.157" : "0.0.0-test";
+var VERSION = true ? "4.0.159" : "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.157" : "0.0.0-test";
+var VERSION = true ? "4.0.159" : "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.157",
+  "version": "4.0.159",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -45,7 +45,7 @@
     "@smithy/util-utf8": "^4.0.0",
     "aws4fetch": "^1.0.20",
     "@ai-sdk/anthropic": "3.0.111",
-    "@ai-sdk/openai": "3.0.98",
+    "@ai-sdk/openai": "3.0.99",
     "@ai-sdk/provider": "3.0.15",
     "@ai-sdk/provider-utils": "4.0.46"
   },

package/src/bedrock-api-types.ts

@@ -213,6 +213,12 @@ export interface BedrockRedactedReasoningContentBlock {
   };
 }
 
+export interface BedrockRedactedContentBlock {
+  reasoningContent: {
+    redactedContent: string;
+  };
+}
+
 export type BedrockContentBlock =
   | BedrockDocumentBlock
   | BedrockGuardrailConverseContentBlock
@@ -222,4 +228,5 @@ export type BedrockContentBlock =
   | BedrockToolUseBlock
   | BedrockReasoningContentBlock
   | BedrockRedactedReasoningContentBlock
+  | BedrockRedactedContentBlock
   | BedrockCachePoint;

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

@@ -528,6 +528,16 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
               } satisfies BedrockReasoningMetadata,
             },
           });
+        } else if ('redactedContent' in part.reasoningContent) {
+          content.push({
+            type: 'reasoning',
+            text: '',
+            providerMetadata: {
+              bedrock: {
+                redactedContent: part.reasoningContent.redactedContent,
+              } satisfies BedrockReasoningMetadata,
+            },
+          });
         }
       }
 
@@ -669,7 +679,8 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
           jsonText: string;
           isJsonResponseTool?: boolean;
         }
-      | { type: 'text' | 'reasoning' }
+      | { type: 'text' }
+      | { type: 'reasoning'; redactedContent?: string }
     > = {};
 
     return {
@@ -719,6 +730,10 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
               enqueueError(value.modelStreamErrorException);
               return;
             }
+            if (value.serviceUnavailableException) {
+              enqueueError(value.serviceUnavailableException);
+              return;
+            }
             if (value.throttlingException) {
               enqueueError(value.throttlingException);
               return;
@@ -838,9 +853,20 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
 
               if (contentBlock != null) {
                 if (contentBlock.type === 'reasoning') {
+                  const redactedPayload: BedrockReasoningMetadata | null =
+                    contentBlock.redactedContent != null
+                      ? { redactedContent: contentBlock.redactedContent }
+                      : null;
                   controller.enqueue({
                     type: 'reasoning-end',
                     id: String(blockIndex),
+                    ...(redactedPayload != null
+                      ? {
+                          providerMetadata: {
+                            bedrock: redactedPayload,
+                          },
+                        }
+                      : {}),
                   });
                 } else if (contentBlock.type === 'text') {
                   controller.enqueue({
@@ -947,6 +973,27 @@ export class BedrockChatLanguageModel implements LanguageModelV3 {
                     } satisfies BedrockReasoningMetadata,
                   },
                 });
+              } 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;
+                }
               }
             }
 
@@ -1160,6 +1207,13 @@ const BedrockResponseSchema = z.object({
               z.object({
                 redactedReasoning: BedrockRedactedReasoningSchema,
               }),
+              // `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(),
         }),
@@ -1206,6 +1260,12 @@ const BedrockStreamSchema = 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(),
     })
@@ -1252,6 +1312,7 @@ const BedrockStreamSchema = 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/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 createBedrockEventStreamDecoder<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/bedrock-event-stream-response-handler.ts

@@ -25,31 +25,40 @@ export const createBedrockEventStreamResponseHandler =
       value: createBedrockEventStreamDecoder<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/bedrock-reasoning-metadata.ts

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

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

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