@ai-sdk/amazon-bedrock 5.0.62 → 5.0.65

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.62" : "0.0.0-test";
+var VERSION = true ? "5.0.65" : "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.62" : "0.0.0-test";
+var VERSION = true ? "5.0.65" : "0.0.0-test";
 
 // src/amazon-bedrock-sigv4-fetch.ts
 function createSigV4FetchFunction(getCredentials, fetch, service = "bedrock") {

package/docs/08-amazon-bedrock.mdx

@@ -292,6 +292,83 @@ if (result.providerMetadata?.bedrock.trace) {
 
 See the [Amazon Bedrock Guardrails documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html) for more information.
 
+#### Guard Content
+
+You can mark individual text or image parts as guard content using `providerOptions` on the part itself. This wraps the part in a [`guardContent`](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html) block, which tells Bedrock Guardrails to evaluate that content specifically.
+
+For text parts, you can also specify `guardContentQualifiers` to indicate how the content should be treated by the guardrail (e.g. as a grounding source, a query, or guard content):
+
+```ts
+const result = await generateText({
+  model: bedrock('anthropic.claude-3-sonnet-20240229-v1:0'),
+  providerOptions: {
+    bedrock: {
+      guardrailConfig: {
+        guardrailIdentifier: '1abcd2ef34gh',
+        guardrailVersion: '1',
+      },
+    },
+  },
+  messages: [
+    {
+      role: 'user',
+      content: [
+        {
+          type: 'text',
+          text: 'London is the capital of UK. Tokyo is the capital of Japan.',
+          providerOptions: {
+            bedrock: {
+              guardContent: true,
+              guardContentQualifiers: ['grounding_source'],
+            },
+          },
+        },
+        {
+          type: 'text',
+          text: 'Some additional background information.',
+        },
+        {
+          type: 'text',
+          text: 'What is the capital of Japan?',
+          providerOptions: {
+            bedrock: {
+              guardContent: true,
+              guardContentQualifiers: ['query'],
+            },
+          },
+        },
+      ],
+    },
+  ],
+});
+```
+
+Image parts can also be marked as guard content:
+
+```ts
+{
+  type: 'file',
+  data: {
+    type: 'data',
+    data: imageBase64,
+  },
+  mediaType: 'image/png',
+  providerOptions: {
+    bedrock: {
+      guardContent: true,
+    },
+  },
+}
+```
+
+The available `guardContentQualifiers` are:
+
+- `'grounding_source'` — content used as a grounding source for the guardrail
+- `'query'` — content treated as a query to evaluate
+- `'guard_content'` — content to be evaluated by the guardrail
+
+See the [Amazon Bedrock Guardrails with Converse API documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails-use-converse-api.html) for more information.
+
 ### Citations
 
 Amazon Bedrock supports citations for document-based inputs across compatible models. When enabled:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/amazon-bedrock",
-  "version": "5.0.62",
+  "version": "5.0.65",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -41,10 +41,10 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "4.0.42",
-    "@ai-sdk/openai": "4.0.47",
+    "@ai-sdk/anthropic": "4.0.44",
+    "@ai-sdk/openai": "4.0.49",
     "@ai-sdk/provider": "4.0.8",
-    "@ai-sdk/provider-utils": "5.0.30",
+    "@ai-sdk/provider-utils": "5.0.32",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",
     "aws4fetch": "^1.0.20"

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

@@ -183,8 +183,16 @@ export interface AmazonBedrockDocumentBlock {
   };
 }
 
+export interface AmazonBedrockGuardrailTextBlock extends AmazonBedrockTextBlock {
+  qualifiers?: Array<'grounding_source' | 'query' | 'guard_content'>;
+}
+
 export interface AmazonBedrockGuardrailConverseContentBlock {
-  guardContent: unknown;
+  guardContent:
+    | {
+        text: AmazonBedrockGuardrailTextBlock;
+      }
+    | AmazonBedrockImageBlock;
 }
 
 export interface AmazonBedrockImageBlock {

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

@@ -106,6 +106,33 @@ export type AmazonBedrockFilePartProviderOptions = z.infer<
   typeof amazonBedrockFilePartProviderOptions
 >;
 
+/**
+ * Amazon Bedrock text part provider options for guardrail content.
+ * These options apply to individual text parts.
+ */
+export const amazonBedrockTextPartProviderOptions = z.object({
+  guardContent: z.boolean().optional(),
+  guardContentQualifiers: z
+    .array(z.enum(['grounding_source', 'query', 'guard_content']))
+    .optional(),
+});
+
+export type AmazonBedrockTextPartProviderOptions = z.infer<
+  typeof amazonBedrockTextPartProviderOptions
+>;
+
+/**
+ * Amazon Bedrock image part provider options for guardrail content.
+ * These options apply to individual image parts.
+ */
+export const amazonBedrockImagePartProviderOptions = z.object({
+  guardContent: z.boolean().optional(),
+});
+
+export type AmazonBedrockImagePartProviderOptions = z.infer<
+  typeof amazonBedrockImagePartProviderOptions
+>;
+
 export const amazonBedrockLanguageModelChatOptions = z.object({
   /**
    * Additional inference parameters that the model supports,

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

@@ -14,6 +14,7 @@ import type {
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
+  createProviderStreamError,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   injectJsonInstructionIntoMessages,
@@ -51,6 +52,10 @@ import {
 } from './amazon-bedrock-anthropic-model-support';
 import { AmazonBedrockErrorSchema } from './amazon-bedrock-error';
 import { createAmazonBedrockEventStreamResponseHandler } from './amazon-bedrock-event-stream-response-handler';
+import {
+  getAmazonBedrockStreamErrorMetadata,
+  type AmazonBedrockStreamErrorType,
+} from './amazon-bedrock-stream-error';
 import { prepareTools } from './amazon-bedrock-prepare-tools';
 import {
   convertAmazonBedrockUsage,
@@ -68,6 +73,32 @@ type AmazonBedrockChatConfig = {
   generateId: () => string;
 };
 
+const anthropicProviderOptions = z.object({
+  disableParallelToolUse: z.boolean().optional(),
+});
+
+function createAmazonBedrockStreamError({
+  type,
+  error,
+  data,
+}: {
+  type: AmazonBedrockStreamErrorType;
+  error: Record<string, unknown>;
+  data: unknown;
+}) {
+  const message =
+    typeof error.message === 'string'
+      ? error.message
+      : `Amazon Bedrock stream failed with ${type}`;
+
+  return createProviderStreamError({
+    message,
+    type,
+    ...getAmazonBedrockStreamErrorMetadata(type),
+    data,
+  });
+}
+
 export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
   readonly provider = 'amazon-bedrock';
@@ -128,6 +159,12 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
       })) ??
       {};
 
+    const anthropicOptions = await parseProviderOptions({
+      provider: 'anthropic',
+      providerOptions,
+      schema: anthropicProviderOptions,
+    });
+
     const warnings: SharedV4Warning[] = [];
 
     if (frequencyPenalty != null) {
@@ -180,7 +217,10 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
     }
 
     const isAnthropicModel = this.modelId.includes('anthropic');
-    const isOpenAIModel = this.modelId.startsWith('openai.');
+    const openAIModelId = /^(?:[^.]+\.)?(openai\..+)$/.exec(this.modelId)?.[1];
+    const isOpenAIModel = openAIModelId != null;
+    const isOpenAIGptOssModel =
+      openAIModelId?.startsWith('openai.gpt-oss-') ?? false;
 
     amazonBedrockOptions = resolveAmazonBedrockReasoningConfig({
       reasoning,
@@ -231,6 +271,7 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
         toolChoice:
           jsonResponseTool != null ? { type: 'required' } : toolChoice,
         modelId: this.modelId,
+        disableParallelToolUse: anthropicOptions?.disableParallelToolUse,
       });
 
     warnings.push(...toolWarnings);
@@ -329,11 +370,20 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
           },
         };
       } else if (isOpenAIModel) {
-        // OpenAI models on Bedrock expect `reasoning_effort` as a flat value
-        amazonBedrockOptions.additionalModelRequestFields = {
-          ...amazonBedrockOptions.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.
+        amazonBedrockOptions.additionalModelRequestFields = isOpenAIGptOssModel
+          ? {
+              ...amazonBedrockOptions.additionalModelRequestFields,
+              reasoning_effort: maxReasoningEffort,
+            }
+          : {
+              ...amazonBedrockOptions.additionalModelRequestFields,
+              reasoning: {
+                ...amazonBedrockOptions.additionalModelRequestFields?.reasoning,
+                effort: maxReasoningEffort,
+              },
+            };
       } else {
         // other models (such as Nova 2) use reasoningConfig format
         amazonBedrockOptions.additionalModelRequestFields = {
@@ -756,9 +806,19 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
           },
 
           transform(chunk, controller) {
-            function enqueueError(amazonBedrockError: Record<string, any>) {
+            function enqueueError(
+              type: AmazonBedrockStreamErrorType,
+              amazonBedrockError: Record<string, unknown>,
+            ) {
               finishReason = { unified: 'error', raw: undefined };
-              controller.enqueue({ type: 'error', error: amazonBedrockError });
+              controller.enqueue({
+                type: 'error',
+                error: createAmazonBedrockStreamError({
+                  type,
+                  error: amazonBedrockError,
+                  data: chunk.rawValue,
+                }),
+              });
             }
 
             // Emit raw chunk if requested (before anything else)
@@ -768,7 +828,8 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
 
             // handle failed chunk parsing / validation:
             if (!chunk.success) {
-              enqueueError(chunk.error);
+              finishReason = { unified: 'error', raw: undefined };
+              controller.enqueue({ type: 'error', error: chunk.error });
               return;
             }
 
@@ -776,23 +837,32 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
 
             // handle errors:
             if (value.internalServerException) {
-              enqueueError(value.internalServerException);
+              enqueueError(
+                'internalServerException',
+                value.internalServerException,
+              );
               return;
             }
             if (value.modelStreamErrorException) {
-              enqueueError(value.modelStreamErrorException);
+              enqueueError(
+                'modelStreamErrorException',
+                value.modelStreamErrorException,
+              );
               return;
             }
             if (value.serviceUnavailableException) {
-              enqueueError(value.serviceUnavailableException);
+              enqueueError(
+                'serviceUnavailableException',
+                value.serviceUnavailableException,
+              );
               return;
             }
             if (value.throttlingException) {
-              enqueueError(value.throttlingException);
+              enqueueError('throttlingException', value.throttlingException);
               return;
             }
             if (value.validationException) {
-              enqueueError(value.validationException);
+              enqueueError('validationException', value.validationException);
               return;
             }
 
@@ -1244,6 +1314,13 @@ const AmazonBedrockRedactedReasoningSchema = 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 AmazonBedrockResponseSchema = z.object({
@@ -1286,16 +1363,16 @@ const AmazonBedrockResponseSchema = 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
@@ -1361,12 +1438,12 @@ const AmazonBedrockStreamSchema = 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/amazon-bedrock-prepare-tools.ts

@@ -19,10 +19,12 @@ export async function prepareTools({
   tools,
   toolChoice,
   modelId,
+  disableParallelToolUse,
 }: {
   tools: LanguageModelV4CallOptions['tools'];
   toolChoice?: LanguageModelV4CallOptions['toolChoice'];
   modelId: string;
+  disableParallelToolUse?: boolean;
 }): Promise<{
   toolConfig: AmazonBedrockToolConfiguration;
   additionalTools: Record<string, unknown> | undefined;
@@ -85,6 +87,7 @@ export async function prepareTools({
     } = await prepareAnthropicTools({
       tools: ProviderTools,
       toolChoice,
+      disableParallelToolUse,
       supportsStructuredOutput: false,
       supportsStrictTools: false,
     });
@@ -161,10 +164,36 @@ export async function prepareTools({
     });
   }
 
+  if (
+    isAnthropicModel &&
+    !usingAnthropicTools &&
+    disableParallelToolUse &&
+    amazonBedrockTools.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 amazonBedrockToolChoice: AmazonBedrockToolConfiguration['toolChoice'] =
     undefined;
-  if (!usingAnthropicTools && amazonBedrockTools.length > 0 && toolChoice) {
+  if (
+    !usingAnthropicTools &&
+    additionalTools?.tool_choice == null &&
+    amazonBedrockTools.length > 0 &&
+    toolChoice
+  ) {
     const type = toolChoice.type;
     switch (type) {
       case 'auto':

package/src/amazon-bedrock-stream-error.ts

@@ -0,0 +1,31 @@
+export type AmazonBedrockStreamErrorType =
+  | 'internalServerException'
+  | 'modelStreamErrorException'
+  | 'serviceUnavailableException'
+  | 'throttlingException'
+  | 'validationException';
+
+export function getAmazonBedrockStreamErrorMetadata(type: string): {
+  statusCode?: number;
+  isRetryable?: boolean;
+} {
+  switch (type) {
+    case 'internalServerException':
+    case 'InternalServerException':
+      return { statusCode: 500, isRetryable: true };
+    case 'modelStreamErrorException':
+    case 'ModelStreamErrorException':
+      return { statusCode: 424, isRetryable: true };
+    case 'serviceUnavailableException':
+    case 'ServiceUnavailableException':
+      return { statusCode: 503, isRetryable: true };
+    case 'throttlingException':
+    case 'ThrottlingException':
+      return { statusCode: 429, isRetryable: true };
+    case 'validationException':
+    case 'ValidationException':
+      return { statusCode: 400, isRetryable: false };
+    default:
+      return {};
+  }
+}

package/src/anthropic/amazon-bedrock-anthropic-fetch.ts

@@ -5,6 +5,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { createAmazonBedrockEventStreamDecoder } from '../amazon-bedrock-event-stream-decoder';
+import { getAmazonBedrockStreamErrorMetadata } from '../amazon-bedrock-stream-error';
 
 const amazonBedrockErrorSchema = z.looseObject({
   message: z.string().optional(),
@@ -93,9 +94,28 @@ function transformAmazonBedrockEventStreamToSSE(
           controller.enqueue(textEncoder.encode('data: [DONE]\n\n'));
         }
       } else if (event.messageType === 'exception') {
+        const parsed = await safeParseJSON({ text: event.data });
+        const data = parsed.success ? parsed.value : event.data;
+        const message =
+          typeof data === 'object' &&
+          data != null &&
+          typeof (data as Record<string, unknown>).message === 'string'
+            ? (data as Record<string, unknown>).message
+            : event.data;
+        const type = event.eventType ?? event.exceptionType ?? 'error';
+        const metadata = getAmazonBedrockStreamErrorMetadata(type);
+
         controller.enqueue(
           textEncoder.encode(
-            `data: ${JSON.stringify({ type: 'error', error: event.data })}\n\n`,
+            `data: ${JSON.stringify({
+              type: 'error',
+              error: {
+                type,
+                message,
+                ...metadata,
+                data,
+              },
+            })}\n\n`,
           ),
         );
       }

package/src/convert-amazon-bedrock-usage.ts

@@ -1,12 +1,18 @@
-import type { LanguageModelV4Usage } from '@ai-sdk/provider';
+import type { JSONValue, LanguageModelV4Usage } from '@ai-sdk/provider';
 import { createNullLanguageModelUsage } from '@ai-sdk/provider-utils';
 
 export type AmazonBedrockUsage = {
+  [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 convertAmazonBedrockUsage(

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

@@ -33,7 +33,11 @@ import {
   type AmazonBedrockVideoFormat,
   type AmazonBedrockVideoMimeType,
 } from './amazon-bedrock-api-types';
-import { amazonBedrockFilePartProviderOptions } from './amazon-bedrock-chat-language-model-options';
+import {
+  amazonBedrockFilePartProviderOptions,
+  amazonBedrockImagePartProviderOptions,
+  amazonBedrockTextPartProviderOptions,
+} from './amazon-bedrock-chat-language-model-options';
 import { amazonBedrockReasoningMetadataSchema } from './amazon-bedrock-reasoning-metadata';
 import { normalizeToolCallId } from './normalize-tool-call-id';
 
@@ -110,6 +114,40 @@ async function shouldEnableCitations(
   return amazonBedrockOptions?.citations?.enabled ?? false;
 }
 
+async function getTextPartGuardContentOptions(
+  providerMetadata: SharedV4ProviderMetadata | undefined,
+) {
+  return (
+    (await parseProviderOptions({
+      provider: 'amazonBedrock',
+      providerOptions: providerMetadata,
+      schema: amazonBedrockTextPartProviderOptions,
+    })) ??
+    (await parseProviderOptions({
+      provider: 'bedrock',
+      providerOptions: providerMetadata,
+      schema: amazonBedrockTextPartProviderOptions,
+    }))
+  );
+}
+
+async function getImagePartGuardContentOptions(
+  providerMetadata: SharedV4ProviderMetadata | undefined,
+) {
+  return (
+    (await parseProviderOptions({
+      provider: 'amazonBedrock',
+      providerOptions: providerMetadata,
+      schema: amazonBedrockImagePartProviderOptions,
+    })) ??
+    (await parseProviderOptions({
+      provider: 'bedrock',
+      providerOptions: providerMetadata,
+      schema: amazonBedrockImagePartProviderOptions,
+    }))
+  );
+}
+
 export async function convertToAmazonBedrockChatMessages(
   prompt: LanguageModelV4Prompt,
   isMistral: boolean = false,
@@ -162,9 +200,24 @@ export async function convertToAmazonBedrockChatMessages(
 
                 switch (part.type) {
                   case 'text': {
-                    amazonBedrockContent.push({
-                      text: part.text,
-                    });
+                    const textOptions = await getTextPartGuardContentOptions(
+                      part.providerOptions,
+                    );
+
+                    if (textOptions?.guardContent) {
+                      amazonBedrockContent.push({
+                        guardContent: {
+                          text: {
+                            text: part.text,
+                            qualifiers: textOptions.guardContentQualifiers,
+                          },
+                        },
+                      });
+                    } else {
+                      amazonBedrockContent.push({
+                        text: part.text,
+                      });
+                    }
                     break;
                   }
 
@@ -251,7 +304,11 @@ export async function convertToAmazonBedrockChatMessages(
 
                         switch (getTopLevelMediaType(fullMediaType)) {
                           case 'image': {
-                            amazonBedrockContent.push({
+                            const imageOptions =
+                              await getImagePartGuardContentOptions(
+                                part.providerOptions,
+                              );
+                            const imageBlock: AmazonBedrockImageBlock = {
                               image: {
                                 format:
                                   getAmazonBedrockImageFormat(fullMediaType),
@@ -260,7 +317,15 @@ export async function convertToAmazonBedrockChatMessages(
                                   functionality: 'File URL data',
                                 }),
                               },
-                            });
+                            };
+
+                            if (imageOptions?.guardContent) {
+                              amazonBedrockContent.push({
+                                guardContent: imageBlock,
+                              });
+                            } else {
+                              amazonBedrockContent.push(imageBlock);
+                            }
                             break;
                           }
                           case 'video': {