@ai-sdk/amazon-bedrock 5.0.0-beta.8 → 5.0.0-beta.85

package/src/bedrock-api-types.ts

@@ -1,216 +0,0 @@
-import { JSONObject } from '@ai-sdk/provider';
-
-export interface BedrockConverseInput {
-  system?: BedrockSystemMessages;
-  messages: BedrockMessages;
-  toolConfig?: BedrockToolConfiguration;
-  inferenceConfig?: {
-    maxOutputTokens?: number;
-    temperature?: number;
-    topP?: number;
-    topK?: number;
-    stopSequences?: string[];
-  };
-  additionalModelRequestFields?: Record<string, unknown>;
-  additionalModelResponseFieldPaths?: string[];
-  guardrailConfig?:
-    | BedrockGuardrailConfiguration
-    | BedrockGuardrailStreamConfiguration
-    | undefined;
-}
-
-export type BedrockSystemMessages = Array<BedrockSystemContentBlock>;
-
-export type BedrockMessages = Array<
-  BedrockAssistantMessage | BedrockUserMessage
->;
-
-export interface BedrockAssistantMessage {
-  role: 'assistant';
-  content: Array<BedrockContentBlock>;
-}
-
-export interface BedrockUserMessage {
-  role: 'user';
-  content: Array<BedrockContentBlock>;
-}
-
-/**
- * Cache TTL options for Bedrock prompt caching.
- * @see https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
- *
- * - '5m': 5-minute TTL (default, supported by all models)
- * - '1h': 1-hour TTL (supported by Claude Opus 4.5, Claude Haiku 4.5, Claude Sonnet 4.5)
- */
-export type BedrockCacheTTL = '5m' | '1h';
-
-export type BedrockCachePoint = {
-  cachePoint: { type: 'default'; ttl?: BedrockCacheTTL };
-};
-
-/**
- * Creates a cache point with an optional TTL.
- * @param ttl - Cache TTL ('5m' or '1h'). If not provided, uses the default 5-minute TTL.
- */
-export function createBedrockCachePoint(
-  ttl?: BedrockCacheTTL,
-): BedrockCachePoint {
-  return {
-    cachePoint: { type: 'default', ttl },
-  };
-}
-
-export type BedrockSystemContentBlock = { text: string } | BedrockCachePoint;
-
-export interface BedrockGuardrailConfiguration {
-  guardrails?: Array<{
-    name: string;
-    description?: string;
-    parameters?: Record<string, unknown>;
-  }>;
-}
-
-export type BedrockGuardrailStreamConfiguration = BedrockGuardrailConfiguration;
-
-export interface BedrockToolInputSchema {
-  json: Record<string, unknown>;
-}
-
-export interface BedrockTool {
-  toolSpec: {
-    name: string;
-    description?: string;
-    strict?: boolean;
-    inputSchema: { json: JSONObject };
-  };
-}
-
-export interface BedrockToolConfiguration {
-  tools?: Array<BedrockTool | BedrockCachePoint>;
-  toolChoice?:
-    | { tool: { name: string } }
-    | { auto: {} }
-    | { any: {} }
-    | undefined;
-}
-
-export const BEDROCK_STOP_REASONS = [
-  'stop',
-  'stop_sequence',
-  'end_turn',
-  'length',
-  'max_tokens',
-  'content-filter',
-  'content_filtered',
-  'guardrail_intervened',
-  'tool-calls',
-  'tool_use',
-] as const;
-
-export type BedrockStopReason = (typeof BEDROCK_STOP_REASONS)[number];
-
-/**
- * @see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html
- */
-export const BEDROCK_IMAGE_MIME_TYPES = {
-  'image/jpeg': 'jpeg',
-  'image/png': 'png',
-  'image/gif': 'gif',
-  'image/webp': 'webp',
-} as const;
-type BedrockImageFormats = typeof BEDROCK_IMAGE_MIME_TYPES;
-export type BedrockImageFormat = BedrockImageFormats[keyof BedrockImageFormats];
-export type BedrockImageMimeType = keyof BedrockImageFormats;
-
-/**
- * @see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html
- */
-export const BEDROCK_DOCUMENT_MIME_TYPES = {
-  'application/pdf': 'pdf',
-  'text/csv': 'csv',
-  'application/msword': 'doc',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
-    'docx',
-  'application/vnd.ms-excel': 'xls',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
-  'text/html': 'html',
-  'text/plain': 'txt',
-  'text/markdown': 'md',
-} as const;
-type BedrockDocumentFormats = typeof BEDROCK_DOCUMENT_MIME_TYPES;
-export type BedrockDocumentFormat =
-  BedrockDocumentFormats[keyof BedrockDocumentFormats];
-export type BedrockDocumentMimeType = keyof BedrockDocumentFormats;
-
-export interface BedrockDocumentBlock {
-  document: {
-    format: BedrockDocumentFormat;
-    name: string;
-    source: {
-      bytes: string;
-    };
-    citations?: {
-      enabled: boolean;
-    };
-  };
-}
-
-export interface BedrockGuardrailConverseContentBlock {
-  guardContent: unknown;
-}
-
-export interface BedrockImageBlock {
-  image: {
-    format: BedrockImageFormat;
-    source: {
-      bytes: string;
-    };
-  };
-}
-
-export interface BedrockToolResultBlock {
-  toolResult: {
-    toolUseId: string;
-    content: Array<BedrockTextBlock | BedrockImageBlock>;
-  };
-}
-
-export interface BedrockToolUseBlock {
-  toolUse: {
-    toolUseId: string;
-    name: string;
-    input: Record<string, unknown>;
-  };
-}
-
-export interface BedrockTextBlock {
-  text: string;
-}
-
-export interface BedrockReasoningContentBlock {
-  reasoningContent: {
-    reasoningText: {
-      text: string;
-      signature?: string;
-    };
-  };
-}
-
-export interface BedrockRedactedReasoningContentBlock {
-  reasoningContent: {
-    redactedReasoning: {
-      data: string;
-    };
-  };
-}
-
-export type BedrockContentBlock =
-  | BedrockDocumentBlock
-  | BedrockGuardrailConverseContentBlock
-  | BedrockImageBlock
-  | BedrockTextBlock
-  | BedrockToolResultBlock
-  | BedrockToolUseBlock
-  | BedrockReasoningContentBlock
-  | BedrockRedactedReasoningContentBlock
-  | BedrockCachePoint;

package/src/bedrock-image-settings.ts

@@ -1,6 +0,0 @@
-export type BedrockImageModelId = 'amazon.nova-canvas-v1:0' | (string & {});
-
-// https://docs.aws.amazon.com/nova/latest/userguide/image-gen-req-resp-structure.html
-export const modelMaxImagesPerCall: Record<BedrockImageModelId, number> = {
-  'amazon.nova-canvas-v1:0': 5,
-};

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

@@ -1,468 +0,0 @@
-import {
-  JSONObject,
-  LanguageModelV4Message,
-  LanguageModelV4Prompt,
-  SharedV4ProviderMetadata,
-  UnsupportedFunctionalityError,
-} from '@ai-sdk/provider';
-import {
-  convertToBase64,
-  parseProviderOptions,
-  stripFileExtension,
-} from '@ai-sdk/provider-utils';
-import {
-  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: SharedV4ProviderMetadata | undefined,
-): BedrockCachePoint | undefined {
-  const cachePointConfig = providerMetadata?.bedrock?.cachePoint as
-    | BedrockCachePoint['cachePoint']
-    | undefined;
-
-  if (!cachePointConfig) {
-    return undefined;
-  }
-
-  return { cachePoint: cachePointConfig };
-}
-
-async function shouldEnableCitations(
-  providerMetadata: SharedV4ProviderMetadata | undefined,
-): Promise<boolean> {
-  const bedrockOptions = await parseProviderOptions({
-    provider: 'bedrock',
-    providerOptions: providerMetadata,
-    schema: bedrockFilePartProviderOptions,
-  });
-
-  return bedrockOptions?.citations?.enabled ?? false;
-}
-
-export async function convertToBedrockChatMessages(
-  prompt: LanguageModelV4Prompt,
-  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 });
-          const cachePoint = getCachePoint(message.providerOptions);
-          if (cachePoint) {
-            system.push(cachePoint);
-          }
-        }
-        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
-                            ? stripFileExtension(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}`);
-            }
-          }
-
-          const cachePoint = getCachePoint(providerOptions);
-          if (cachePoint) {
-            bedrockContent.push(cachePoint);
-          }
-        }
-
-        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;
-              }
-            }
-          }
-          const cachePoint = getCachePoint(message.providerOptions);
-          if (cachePoint) {
-            bedrockContent.push(cachePoint);
-          }
-        }
-
-        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<LanguageModelV4Message & { role: 'system' }>;
-};
-type AssistantBlock = {
-  type: 'assistant';
-  messages: Array<LanguageModelV4Message & { role: 'assistant' }>;
-};
-type UserBlock = {
-  type: 'user';
-  messages: Array<LanguageModelV4Message & { role: 'user' | 'tool' }>;
-};
-
-function groupIntoBlocks(
-  prompt: LanguageModelV4Prompt,
-): 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;
-}