@ai-sdk/amazon-bedrock 5.0.74 → 5.0.75

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.74" : "0.0.0-test";
+var VERSION = true ? "5.0.75" : "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.74" : "0.0.0-test";
+var VERSION = true ? "5.0.75" : "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.74",
+  "version": "5.0.75",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@ai-sdk/anthropic": "4.0.49",
-    "@ai-sdk/openai": "4.0.58",
+    "@ai-sdk/openai": "4.0.59",
     "@ai-sdk/provider": "4.0.10",
     "@ai-sdk/provider-utils": "5.0.36",
     "@smithy/eventstream-codec": "^4.3.3",

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

@@ -632,10 +632,17 @@ export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
     // map response content to content array
     for (const part of response.output.message.content) {
       // text
-      if (part.text != null) {
+      const textParts =
+        part.text != null
+          ? [part.text]
+          : (part.citationsContent?.content?.flatMap(content =>
+              content.text == null ? [] : [content.text],
+            ) ?? []);
+
+      for (const text of textParts) {
         content.push({
           type: 'text',
-          text: jsonObjectTextExtractor?.process(part.text) ?? part.text,
+          text: jsonObjectTextExtractor?.process(text) ?? text,
         });
       }
 
@@ -1381,6 +1388,17 @@ const AmazonBedrockResponseSchema = z.object({
       content: z.array(
         z.object({
           text: z.string().nullish(),
+          citationsContent: z
+            .object({
+              content: z
+                .array(
+                  z.object({
+                    text: z.string().nullish(),
+                  }),
+                )
+                .nullish(),
+            })
+            .nullish(),
           toolUse: AmazonBedrockToolUseSchema.nullish(),
           reasoningContent: z
             .union([

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

@@ -5,6 +5,7 @@ import {
   type JSONValue,
   type LanguageModelV4Message,
   type LanguageModelV4Prompt,
+  type LanguageModelV4ToolResultPart,
   type SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
 import {
@@ -28,6 +29,7 @@ import {
   type AmazonBedrockImageMimeType,
   type AmazonBedrockMessages,
   type AmazonBedrockSystemMessages,
+  type AmazonBedrockToolResultBlock,
   type AmazonBedrockUserMessage,
   type AmazonBedrockVideoBlock,
   type AmazonBedrockVideoFormat,
@@ -72,6 +74,15 @@ function sanitizeToolName(toolName: string): string {
   return toolName.replace(/[^a-zA-Z0-9_-]/g, '') || '_';
 }
 
+function sanitizeDocumentName(filename: string): string {
+  return stripFileExtension(filename)
+    .replace(/\s+/g, ' ')
+    .replace(/[^a-zA-Z0-9 ()[\]-]/g, '')
+    .trim()
+    .slice(0, 200)
+    .trim();
+}
+
 function getAmazonBedrockMediaSource({
   data,
   functionality,
@@ -162,6 +173,8 @@ export async function convertToAmazonBedrockChatMessages(
 
   let documentCounter = 0;
   const generateDocumentName = () => `document-${++documentCounter}`;
+  const getDocumentName = (filename: string | undefined) =>
+    (filename && sanitizeDocumentName(filename)) || generateDocumentName();
 
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i];
@@ -284,9 +297,7 @@ export async function convertToAmazonBedrockChatMessages(
                           document: {
                             format:
                               getAmazonBedrockDocumentFormat(textMediaType),
-                            name: part.filename
-                              ? stripFileExtension(part.filename)
-                              : generateDocumentName(),
+                            name: getDocumentName(part.filename),
                             source: {
                               bytes: convertToBase64(
                                 new TextEncoder().encode(part.data.text),
@@ -350,9 +361,7 @@ export async function convertToAmazonBedrockChatMessages(
                               document: {
                                 format:
                                   getAmazonBedrockDocumentFormat(fullMediaType),
-                                name: part.filename
-                                  ? stripFileExtension(part.filename)
-                                  : generateDocumentName(),
+                                name: getDocumentName(part.filename),
                                 source: {
                                   bytes: convertToBase64(part.data.data),
                                 },
@@ -381,126 +390,14 @@ export async function convertToAmazonBedrockChatMessages(
                 if (part.type === 'tool-approval-response') {
                   continue;
                 }
-                let toolResultContent;
-
-                const output = part.output;
-                switch (output.type) {
-                  case 'content': {
-                    toolResultContent = await Promise.all(
-                      output.value.map(async contentPart => {
-                        switch (contentPart.type) {
-                          case 'text':
-                            return { text: contentPart.text };
-                          case 'file': {
-                            if (
-                              contentPart.data.type !== 'data' &&
-                              (contentPart.data.type !== 'url' ||
-                                contentPart.data.url.protocol !== 's3:')
-                            ) {
-                              throw new UnsupportedFunctionalityError({
-                                functionality: `tool result file data of type "${contentPart.data.type}"`,
-                              });
-                            }
-
-                            const fullMediaType = resolveFullMediaType({
-                              part: contentPart,
-                            });
-
-                            switch (getTopLevelMediaType(fullMediaType)) {
-                              case 'image': {
-                                return {
-                                  image: {
-                                    format:
-                                      getAmazonBedrockImageFormat(
-                                        fullMediaType,
-                                      ),
-                                    source: getAmazonBedrockMediaSource({
-                                      data: contentPart.data,
-                                      functionality: `tool result file data of type "${contentPart.data.type}"`,
-                                    }),
-                                  },
-                                };
-                              }
-                              case 'video': {
-                                return {
-                                  video: {
-                                    format:
-                                      getAmazonBedrockVideoFormat(
-                                        fullMediaType,
-                                      ),
-                                    source: getAmazonBedrockMediaSource({
-                                      data: contentPart.data,
-                                      functionality: `tool result file data of type "${contentPart.data.type}"`,
-                                    }),
-                                  },
-                                };
-                              }
-                              default: {
-                                if (contentPart.data.type !== 'data') {
-                                  throw new UnsupportedFunctionalityError({
-                                    functionality: `tool result file data of type "${contentPart.data.type}"`,
-                                  });
-                                }
-
-                                const enableCitations =
-                                  await shouldEnableCitations(
-                                    contentPart.providerOptions,
-                                  );
-
-                                return {
-                                  document: {
-                                    format:
-                                      getAmazonBedrockDocumentFormat(
-                                        fullMediaType,
-                                      ),
-                                    name: contentPart.filename
-                                      ? stripFileExtension(contentPart.filename)
-                                      : generateDocumentName(),
-                                    source: {
-                                      bytes: convertToBase64(
-                                        contentPart.data.data,
-                                      ),
-                                    },
-                                    ...(enableCitations && {
-                                      citations: { enabled: true },
-                                    }),
-                                  },
-                                };
-                              }
-                            }
-                          }
-                          default: {
-                            throw new UnsupportedFunctionalityError({
-                              functionality: `unsupported tool content part type: ${contentPart.type}`,
-                            });
-                          }
-                        }
-                      }),
-                    );
-                    break;
-                  }
-                  case 'text':
-                  case 'error-text':
-                    toolResultContent = [{ text: output.value }];
-                    break;
-                  case 'execution-denied':
-                    toolResultContent = [
-                      { text: output.reason ?? 'Tool call execution denied.' },
-                    ];
-                    break;
-                  case 'json':
-                  case 'error-json':
-                  default:
-                    toolResultContent = [
-                      { text: JSON.stringify(output.value) },
-                    ];
-                    break;
-                }
 
                 amazonBedrockContent.push({
                   toolResult: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
-                    content: toolResultContent,
+                    content: await convertToolResultOutput({
+                      output: part.output,
+                      getDocumentName,
+                    }),
                   },
                 });
                 pushCachePoint(amazonBedrockContent, part.providerOptions);
@@ -517,15 +414,28 @@ export async function convertToAmazonBedrockChatMessages(
           pushCachePoint(amazonBedrockContent, providerOptions);
         }
 
-        messages.push({ role: 'user', content: amazonBedrockContent });
+        appendToUserMessage(messages, amazonBedrockContent);
 
         break;
       }
 
       case 'assistant': {
-        // combines multiple assistant messages in this block into a single message:
-        const amazonBedrockContent: AmazonBedrockAssistantMessage['content'] =
-          [];
+        let assistantContent: AmazonBedrockAssistantMessage['content'] = [];
+        let toolResultContent: AmazonBedrockUserMessage['content'] = [];
+
+        const flushAssistantContent = () => {
+          if (assistantContent.some(block => !('cachePoint' in block))) {
+            messages.push({ role: 'assistant', content: assistantContent });
+          }
+          assistantContent = [];
+        };
+
+        const flushToolResultContent = () => {
+          if (toolResultContent.length > 0) {
+            appendToUserMessage(messages, toolResultContent);
+            toolResultContent = [];
+          }
+        };
 
         for (let j = 0; j < block.messages.length; j++) {
           const message = block.messages[j];
@@ -539,6 +449,10 @@ export async function convertToAmazonBedrockChatMessages(
             const part = content[k];
             const isLastContentPart = k === content.length - 1;
 
+            if (part.type !== 'tool-result') {
+              flushToolResultContent();
+            }
+
             switch (part.type) {
               case 'text': {
                 // Skip empty text blocks unless reasoning blocks are present
@@ -546,7 +460,7 @@ export async function convertToAmazonBedrockChatMessages(
                   break;
                 }
 
-                amazonBedrockContent.push({
+                assistantContent.push({
                   text:
                     // trim the last text part if it's the last message in the block
                     // because Bedrock does not allow trailing whitespace
@@ -577,7 +491,7 @@ export async function convertToAmazonBedrockChatMessages(
                 if (reasoningMetadata?.signature != null) {
                   // do not trim reasoning text when a signature is present:
                   // the signature validates the exact original bytes
-                  amazonBedrockContent.push({
+                  assistantContent.push({
                     reasoningContent: {
                       reasoningText: {
                         text: part.text,
@@ -586,13 +500,13 @@ export async function convertToAmazonBedrockChatMessages(
                     },
                   });
                 } else if (reasoningMetadata?.redactedContent != null) {
-                  amazonBedrockContent.push({
+                  assistantContent.push({
                     reasoningContent: {
                       redactedContent: reasoningMetadata.redactedContent,
                     },
                   });
                 } else if (reasoningMetadata?.redactedData != null) {
-                  amazonBedrockContent.push({
+                  assistantContent.push({
                     reasoningContent: {
                       redactedReasoning: {
                         data: reasoningMetadata.redactedData,
@@ -608,7 +522,7 @@ export async function convertToAmazonBedrockChatMessages(
               }
 
               case 'tool-call': {
-                amazonBedrockContent.push({
+                assistantContent.push({
                   toolUse: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
                     name: sanitizeToolName(part.toolName),
@@ -617,17 +531,41 @@ export async function convertToAmazonBedrockChatMessages(
                 });
                 break;
               }
+
+              case 'tool-result': {
+                flushAssistantContent();
+                toolResultContent.push({
+                  toolResult: {
+                    toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
+                    content: await convertToolResultOutput({
+                      output: part.output,
+                      getDocumentName,
+                    }),
+                  },
+                });
+                break;
+              }
             }
 
-            pushCachePoint(amazonBedrockContent, part.providerOptions);
+            pushCachePoint(
+              part.type === 'tool-result'
+                ? toolResultContent
+                : assistantContent,
+              part.providerOptions,
+            );
           }
-          pushCachePoint(amazonBedrockContent, message.providerOptions);
-        }
 
-        if (amazonBedrockContent.some(block => !('cachePoint' in block))) {
-          messages.push({ role: 'assistant', content: amazonBedrockContent });
+          pushCachePoint(
+            content[content.length - 1]?.type === 'tool-result'
+              ? toolResultContent
+              : assistantContent,
+            message.providerOptions,
+          );
         }
 
+        flushToolResultContent();
+        flushAssistantContent();
+
         break;
       }
 
@@ -641,6 +579,118 @@ export async function convertToAmazonBedrockChatMessages(
   return { system, messages };
 }
 
+// A trailing assistant tool result and the following user content must share a
+// single Bedrock user message so that conversation roles continue to alternate.
+function appendToUserMessage(
+  messages: AmazonBedrockMessages,
+  content: AmazonBedrockUserMessage['content'],
+) {
+  const lastMessage = messages[messages.length - 1];
+
+  if (
+    lastMessage?.role === 'user' &&
+    lastMessage.content.some(block => 'toolResult' in block)
+  ) {
+    lastMessage.content.push(...content);
+  } else {
+    messages.push({ role: 'user', content });
+  }
+}
+
+async function convertToolResultOutput({
+  output,
+  getDocumentName,
+}: {
+  output: LanguageModelV4ToolResultPart['output'];
+  getDocumentName: (filename: string | undefined) => string;
+}): Promise<AmazonBedrockToolResultBlock['toolResult']['content']> {
+  switch (output.type) {
+    case 'content': {
+      return Promise.all(
+        output.value.map(async contentPart => {
+          switch (contentPart.type) {
+            case 'text':
+              return { text: contentPart.text };
+            case 'file': {
+              if (
+                contentPart.data.type !== 'data' &&
+                (contentPart.data.type !== 'url' ||
+                  contentPart.data.url.protocol !== 's3:')
+              ) {
+                throw new UnsupportedFunctionalityError({
+                  functionality: `tool result file data of type "${contentPart.data.type}"`,
+                });
+              }
+
+              const fullMediaType = resolveFullMediaType({ part: contentPart });
+
+              switch (getTopLevelMediaType(fullMediaType)) {
+                case 'image':
+                  return {
+                    image: {
+                      format: getAmazonBedrockImageFormat(fullMediaType),
+                      source: getAmazonBedrockMediaSource({
+                        data: contentPart.data,
+                        functionality: `tool result file data of type "${contentPart.data.type}"`,
+                      }),
+                    },
+                  };
+                case 'video':
+                  return {
+                    video: {
+                      format: getAmazonBedrockVideoFormat(fullMediaType),
+                      source: getAmazonBedrockMediaSource({
+                        data: contentPart.data,
+                        functionality: `tool result file data of type "${contentPart.data.type}"`,
+                      }),
+                    },
+                  };
+                default: {
+                  if (contentPart.data.type !== 'data') {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: `tool result file data of type "${contentPart.data.type}"`,
+                    });
+                  }
+
+                  const enableCitations = await shouldEnableCitations(
+                    contentPart.providerOptions,
+                  );
+
+                  return {
+                    document: {
+                      format: getAmazonBedrockDocumentFormat(fullMediaType),
+                      name: getDocumentName(contentPart.filename),
+                      source: {
+                        bytes: convertToBase64(contentPart.data.data),
+                      },
+                      ...(enableCitations && {
+                        citations: { enabled: true },
+                      }),
+                    },
+                  };
+                }
+              }
+            }
+            default:
+              throw new UnsupportedFunctionalityError({
+                functionality: `unsupported tool content part type: ${contentPart.type}`,
+              });
+          }
+        }),
+      );
+    }
+    case 'text':
+    case 'error-text':
+      return [{ text: output.value }];
+    case 'execution-denied':
+      return [{ text: output.reason ?? 'Tool call execution denied.' }];
+    case 'json':
+    case 'error-json':
+    default:
+      return [{ text: JSON.stringify(output.value) }];
+  }
+}
+
 // wrap invalid tool call input because Bedrock requires it to be an object
 function toBedrockToolInput(input: unknown): JSONObject {
   return typeof input === 'object' && input !== null && !Array.isArray(input)