@ai-sdk/amazon-bedrock 4.0.24 → 4.0.26

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

@@ -0,0 +1,452 @@
+import {
+  JSONObject,
+  LanguageModelV3Message,
+  LanguageModelV3Prompt,
+  SharedV3ProviderMetadata,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { convertToBase64, parseProviderOptions } from '@ai-sdk/provider-utils';
+import {
+  BEDROCK_CACHE_POINT,
+  BEDROCK_DOCUMENT_MIME_TYPES,
+  BEDROCK_IMAGE_MIME_TYPES,
+  BedrockAssistantMessage,
+  BedrockCachePoint,
+  BedrockDocumentFormat,
+  BedrockDocumentMimeType,
+  BedrockImageFormat,
+  BedrockImageMimeType,
+  BedrockMessages,
+  BedrockSystemMessages,
+  BedrockUserMessage,
+} from './bedrock-api-types';
+import { bedrockReasoningMetadataSchema } from './bedrock-chat-language-model';
+import { bedrockFilePartProviderOptions } from './bedrock-chat-options';
+import { normalizeToolCallId } from './normalize-tool-call-id';
+
+function getCachePoint(
+  providerMetadata: SharedV3ProviderMetadata | undefined,
+): BedrockCachePoint | undefined {
+  return providerMetadata?.bedrock?.cachePoint as BedrockCachePoint | undefined;
+}
+
+async function shouldEnableCitations(
+  providerMetadata: SharedV3ProviderMetadata | undefined,
+): Promise<boolean> {
+  const bedrockOptions = await parseProviderOptions({
+    provider: 'bedrock',
+    providerOptions: providerMetadata,
+    schema: bedrockFilePartProviderOptions,
+  });
+
+  return bedrockOptions?.citations?.enabled ?? false;
+}
+
+export async function convertToBedrockChatMessages(
+  prompt: LanguageModelV3Prompt,
+  isMistral: boolean = false,
+): Promise<{
+  system: BedrockSystemMessages;
+  messages: BedrockMessages;
+}> {
+  const blocks = groupIntoBlocks(prompt);
+
+  let system: BedrockSystemMessages = [];
+  const messages: BedrockMessages = [];
+
+  let documentCounter = 0;
+  const generateDocumentName = () => `document-${++documentCounter}`;
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const isLastBlock = i === blocks.length - 1;
+    const type = block.type;
+
+    switch (type) {
+      case 'system': {
+        if (messages.length > 0) {
+          throw new UnsupportedFunctionalityError({
+            functionality:
+              'Multiple system messages that are separated by user/assistant messages',
+          });
+        }
+
+        for (const message of block.messages) {
+          system.push({ text: message.content });
+          if (getCachePoint(message.providerOptions)) {
+            system.push(BEDROCK_CACHE_POINT);
+          }
+        }
+        break;
+      }
+
+      case 'user': {
+        // combines all user and tool messages in this block into a single message:
+        const bedrockContent: BedrockUserMessage['content'] = [];
+
+        for (const message of block.messages) {
+          const { role, content, providerOptions } = message;
+          switch (role) {
+            case 'user': {
+              for (let j = 0; j < content.length; j++) {
+                const part = content[j];
+
+                switch (part.type) {
+                  case 'text': {
+                    bedrockContent.push({
+                      text: part.text,
+                    });
+                    break;
+                  }
+
+                  case 'file': {
+                    if (part.data instanceof URL) {
+                      // The AI SDK automatically downloads files for user file parts with URLs
+                      throw new UnsupportedFunctionalityError({
+                        functionality: 'File URL data',
+                      });
+                    }
+
+                    if (part.mediaType.startsWith('image/')) {
+                      bedrockContent.push({
+                        image: {
+                          format: getBedrockImageFormat(part.mediaType),
+                          source: { bytes: convertToBase64(part.data) },
+                        },
+                      });
+                    } else {
+                      if (!part.mediaType) {
+                        throw new UnsupportedFunctionalityError({
+                          functionality: 'file without mime type',
+                          message:
+                            'File mime type is required in user message part content',
+                        });
+                      }
+
+                      const enableCitations = await shouldEnableCitations(
+                        part.providerOptions,
+                      );
+
+                      bedrockContent.push({
+                        document: {
+                          format: getBedrockDocumentFormat(part.mediaType),
+                          name: part.filename ?? generateDocumentName(),
+                          source: { bytes: convertToBase64(part.data) },
+                          ...(enableCitations && {
+                            citations: { enabled: true },
+                          }),
+                        },
+                      });
+                    }
+
+                    break;
+                  }
+                }
+              }
+
+              break;
+            }
+            case 'tool': {
+              for (const part of content) {
+                if (part.type === 'tool-approval-response') {
+                  continue;
+                }
+                let toolResultContent;
+
+                const output = part.output;
+                switch (output.type) {
+                  case 'content': {
+                    toolResultContent = output.value.map(contentPart => {
+                      switch (contentPart.type) {
+                        case 'text':
+                          return { text: contentPart.text };
+                        case 'image-data':
+                          if (!contentPart.mediaType.startsWith('image/')) {
+                            throw new UnsupportedFunctionalityError({
+                              functionality: `media type: ${contentPart.mediaType}`,
+                            });
+                          }
+
+                          const format = getBedrockImageFormat(
+                            contentPart.mediaType,
+                          );
+
+                          return {
+                            image: {
+                              format,
+                              source: { bytes: contentPart.data },
+                            },
+                          };
+                        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 execution denied.' },
+                    ];
+                    break;
+                  case 'json':
+                  case 'error-json':
+                  default:
+                    toolResultContent = [
+                      { text: JSON.stringify(output.value) },
+                    ];
+                    break;
+                }
+
+                bedrockContent.push({
+                  toolResult: {
+                    toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
+                    content: toolResultContent,
+                  },
+                });
+              }
+
+              break;
+            }
+            default: {
+              const _exhaustiveCheck: never = role;
+              throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+            }
+          }
+
+          if (getCachePoint(providerOptions)) {
+            bedrockContent.push(BEDROCK_CACHE_POINT);
+          }
+        }
+
+        messages.push({ role: 'user', content: bedrockContent });
+
+        break;
+      }
+
+      case 'assistant': {
+        // combines multiple assistant messages in this block into a single message:
+        const bedrockContent: BedrockAssistantMessage['content'] = [];
+
+        for (let j = 0; j < block.messages.length; j++) {
+          const message = block.messages[j];
+          const isLastMessage = j === block.messages.length - 1;
+          const { content } = message;
+
+          for (let k = 0; k < content.length; k++) {
+            const part = content[k];
+            const isLastContentPart = k === content.length - 1;
+
+            switch (part.type) {
+              case 'text': {
+                // Skip empty text blocks
+                if (!part.text.trim()) {
+                  break;
+                }
+
+                bedrockContent.push({
+                  text:
+                    // trim the last text part if it's the last message in the block
+                    // because Bedrock does not allow trailing whitespace
+                    // in pre-filled assistant responses
+                    trimIfLast(
+                      isLastBlock,
+                      isLastMessage,
+                      isLastContentPart,
+                      part.text,
+                    ),
+                });
+                break;
+              }
+
+              case 'reasoning': {
+                const reasoningMetadata = await parseProviderOptions({
+                  provider: 'bedrock',
+                  providerOptions: part.providerOptions,
+                  schema: bedrockReasoningMetadataSchema,
+                });
+
+                if (reasoningMetadata != null) {
+                  if (reasoningMetadata.signature != null) {
+                    bedrockContent.push({
+                      reasoningContent: {
+                        reasoningText: {
+                          // trim the last text part if it's the last message in the block
+                          // because Bedrock does not allow trailing whitespace
+                          // in pre-filled assistant responses
+                          text: trimIfLast(
+                            isLastBlock,
+                            isLastMessage,
+                            isLastContentPart,
+                            part.text,
+                          ),
+                          signature: reasoningMetadata.signature,
+                        },
+                      },
+                    });
+                  } else if (reasoningMetadata.redactedData != null) {
+                    bedrockContent.push({
+                      reasoningContent: {
+                        redactedReasoning: {
+                          data: reasoningMetadata.redactedData,
+                        },
+                      },
+                    });
+                  }
+                }
+
+                break;
+              }
+
+              case 'tool-call': {
+                bedrockContent.push({
+                  toolUse: {
+                    toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
+                    name: part.toolName,
+                    input: part.input as JSONObject,
+                  },
+                });
+                break;
+              }
+            }
+          }
+          if (getCachePoint(message.providerOptions)) {
+            bedrockContent.push(BEDROCK_CACHE_POINT);
+          }
+        }
+
+        messages.push({ role: 'assistant', content: bedrockContent });
+
+        break;
+      }
+
+      default: {
+        const _exhaustiveCheck: never = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return { system, messages };
+}
+
+function isBedrockImageFormat(format: string): format is BedrockImageFormat {
+  return Object.values(BEDROCK_IMAGE_MIME_TYPES).includes(
+    format as BedrockImageFormat,
+  );
+}
+
+function getBedrockImageFormat(mimeType?: string): BedrockImageFormat {
+  if (!mimeType) {
+    throw new UnsupportedFunctionalityError({
+      functionality: 'image without mime type',
+      message: 'Image mime type is required in user message part content',
+    });
+  }
+
+  const format = BEDROCK_IMAGE_MIME_TYPES[mimeType as BedrockImageMimeType];
+  if (!format) {
+    throw new UnsupportedFunctionalityError({
+      functionality: `image mime type: ${mimeType}`,
+      message: `Unsupported image mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_IMAGE_MIME_TYPES).join(', ')}`,
+    });
+  }
+
+  return format;
+}
+
+function getBedrockDocumentFormat(mimeType: string): BedrockDocumentFormat {
+  const format =
+    BEDROCK_DOCUMENT_MIME_TYPES[mimeType as BedrockDocumentMimeType];
+  if (!format) {
+    throw new UnsupportedFunctionalityError({
+      functionality: `file mime type: ${mimeType}`,
+      message: `Unsupported file mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_DOCUMENT_MIME_TYPES).join(', ')}`,
+    });
+  }
+  return format;
+}
+
+function trimIfLast(
+  isLastBlock: boolean,
+  isLastMessage: boolean,
+  isLastContentPart: boolean,
+  text: string,
+) {
+  return isLastBlock && isLastMessage && isLastContentPart ? text.trim() : text;
+}
+
+type SystemBlock = {
+  type: 'system';
+  messages: Array<LanguageModelV3Message & { role: 'system' }>;
+};
+type AssistantBlock = {
+  type: 'assistant';
+  messages: Array<LanguageModelV3Message & { role: 'assistant' }>;
+};
+type UserBlock = {
+  type: 'user';
+  messages: Array<LanguageModelV3Message & { role: 'user' | 'tool' }>;
+};
+
+function groupIntoBlocks(
+  prompt: LanguageModelV3Prompt,
+): Array<SystemBlock | AssistantBlock | UserBlock> {
+  const blocks: Array<SystemBlock | AssistantBlock | UserBlock> = [];
+  let currentBlock: SystemBlock | AssistantBlock | UserBlock | undefined =
+    undefined;
+
+  for (const message of prompt) {
+    const { role } = message;
+    switch (role) {
+      case 'system': {
+        if (currentBlock?.type !== 'system') {
+          currentBlock = { type: 'system', messages: [] };
+          blocks.push(currentBlock);
+        }
+
+        currentBlock.messages.push(message);
+        break;
+      }
+      case 'assistant': {
+        if (currentBlock?.type !== 'assistant') {
+          currentBlock = { type: 'assistant', messages: [] };
+          blocks.push(currentBlock);
+        }
+
+        currentBlock.messages.push(message);
+        break;
+      }
+      case 'user': {
+        if (currentBlock?.type !== 'user') {
+          currentBlock = { type: 'user', messages: [] };
+          blocks.push(currentBlock);
+        }
+
+        currentBlock.messages.push(message);
+        break;
+      }
+      case 'tool': {
+        if (currentBlock?.type !== 'user') {
+          currentBlock = { type: 'user', messages: [] };
+          blocks.push(currentBlock);
+        }
+
+        currentBlock.messages.push(message);
+        break;
+      }
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return blocks;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export type { AnthropicProviderOptions } from '@ai-sdk/anthropic';
+
+export type { BedrockProviderOptions } from './bedrock-chat-options';
+export { bedrock, createAmazonBedrock } from './bedrock-provider';
+export type {
+  AmazonBedrockProvider,
+  AmazonBedrockProviderSettings,
+} from './bedrock-provider';
+export type { BedrockRerankingOptions } from './reranking/bedrock-reranking-options';
+export { VERSION } from './version';

package/src/inject-fetch-headers.test.ts

@@ -0,0 +1,135 @@
+import { injectFetchHeaders } from './inject-fetch-headers';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock the version module
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+// // Mock provider-utils to control runtime environment detection
+vi.mock('@ai-sdk/provider-utils', async () => {
+  const actual = await vi.importActual('@ai-sdk/provider-utils');
+  return {
+    ...actual,
+    getRuntimeEnvironmentUserAgent: vi.fn(() => 'runtime/testenv'),
+  };
+});
+
+describe('injectFetchHeaders', () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    globalThis.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    vi.clearAllMocks();
+  });
+
+  it('should inject custom headers into fetch request', async () => {
+    const mockFetch = vi.fn().mockResolvedValue('response');
+    globalThis.fetch = mockFetch;
+
+    const customHeaders = {
+      'x-custom-header': 'custom-value',
+      authorization: 'Bearer token',
+    };
+
+    const enhancedFetch = injectFetchHeaders(customHeaders);
+    await enhancedFetch('https://api.example.com');
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.example.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-custom-header': 'custom-value',
+          authorization: 'Bearer token',
+          'user-agent': 'ai-sdk/amazon-bedrock/0.0.0-test runtime/testenv',
+        }),
+      }),
+    );
+  });
+
+  it('should merge custom headers with existing headers', async () => {
+    const mockFetch = vi.fn().mockResolvedValue('response');
+    globalThis.fetch = mockFetch;
+
+    const customHeaders = {
+      'x-custom-header': 'custom-value',
+    };
+
+    const existingHeaders = {
+      'Content-Type': 'application/json',
+    };
+
+    const enhancedFetch = injectFetchHeaders(customHeaders);
+    await enhancedFetch('https://api.example.com', {
+      headers: existingHeaders,
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.example.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'content-type': 'application/json',
+          'x-custom-header': 'custom-value',
+          'user-agent': 'ai-sdk/amazon-bedrock/0.0.0-test runtime/testenv',
+        }),
+      }),
+    );
+  });
+
+  it('should handle undefined headers in init', async () => {
+    const mockFetch = vi.fn().mockResolvedValue('response');
+    globalThis.fetch = mockFetch;
+
+    const customHeaders = {
+      'x-custom-header': 'custom-value',
+    };
+
+    const enhancedFetch = injectFetchHeaders(customHeaders);
+    await enhancedFetch('https://api.example.com', {
+      headers: undefined,
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.example.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-custom-header': 'custom-value',
+          'user-agent': 'ai-sdk/amazon-bedrock/0.0.0-test runtime/testenv',
+        }),
+      }),
+    );
+  });
+
+  it('should handle Headers instance in init', async () => {
+    const mockFetch = vi.fn().mockResolvedValue('response');
+    globalThis.fetch = mockFetch;
+
+    const customHeaders = {
+      'x-custom-header': 'custom-value',
+    };
+
+    const existingHeaders = new Headers({
+      'Content-Type': 'application/json',
+    });
+
+    const enhancedFetch = injectFetchHeaders(customHeaders);
+    await enhancedFetch('https://api.example.com', {
+      headers: existingHeaders,
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.example.com',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'content-type': 'application/json',
+          'x-custom-header': 'custom-value',
+          'user-agent': 'ai-sdk/amazon-bedrock/0.0.0-test runtime/testenv',
+        }),
+      }),
+    );
+  });
+});

package/src/inject-fetch-headers.ts

@@ -0,0 +1,32 @@
+import {
+  type FetchFunction,
+  getRuntimeEnvironmentUserAgent,
+  normalizeHeaders,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from './version';
+
+/**
+ * Test helper to inject custom headers into a fetch request.
+ * @param customHeaders - The headers to inject.
+ * @returns A fetch function that injects the custom headers.
+ */
+export function injectFetchHeaders(
+  customHeaders: Record<string, string>,
+): FetchFunction {
+  return async (input, init = {}) => {
+    const headers = withUserAgentSuffix(
+      {
+        ...normalizeHeaders(init.headers),
+        ...customHeaders,
+      },
+      `ai-sdk/amazon-bedrock/${VERSION}`,
+      getRuntimeEnvironmentUserAgent(),
+    );
+
+    return await globalThis.fetch(input, {
+      ...init,
+      headers,
+    });
+  };
+}

package/src/map-bedrock-finish-reason.ts

@@ -0,0 +1,22 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+import { BedrockStopReason } from './bedrock-api-types';
+
+export function mapBedrockFinishReason(
+  finishReason: BedrockStopReason,
+  isJsonResponseFromTool?: boolean,
+): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'stop_sequence':
+    case 'end_turn':
+      return 'stop';
+    case 'max_tokens':
+      return 'length';
+    case 'content_filtered':
+    case 'guardrail_intervened':
+      return 'content-filter';
+    case 'tool_use':
+      return isJsonResponseFromTool ? 'stop' : 'tool-calls';
+    default:
+      return 'other';
+  }
+}