@ai-sdk/amazon-bedrock 4.0.24 → 4.0.26

package/src/anthropic/bedrock-anthropic-provider.ts

@@ -0,0 +1,357 @@
+import {
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadOptionalSetting,
+  loadSetting,
+  Resolvable,
+  resolve,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import {
+  anthropicTools,
+  AnthropicMessagesLanguageModel,
+} from '@ai-sdk/anthropic/internal';
+import {
+  BedrockCredentials,
+  createApiKeyFetchFunction,
+  createSigV4FetchFunction,
+} from '../bedrock-sigv4-fetch';
+import { createBedrockAnthropicFetch } from './bedrock-anthropic-fetch';
+import { BedrockAnthropicModelId } from './bedrock-anthropic-options';
+import { VERSION } from '../version';
+
+// Bedrock requires newer tool versions than the default Anthropic SDK versions
+const BEDROCK_TOOL_VERSION_MAP = {
+  bash_20241022: 'bash_20250124',
+  text_editor_20241022: 'text_editor_20250728',
+  computer_20241022: 'computer_20250124',
+} as const;
+
+// Tool name mappings when upgrading versions (text_editor_20250728 requires different name)
+const BEDROCK_TOOL_NAME_MAP: Record<string, string> = {
+  text_editor_20250728: 'str_replace_based_edit_tool',
+};
+
+// Map tool types to required anthropic_beta values for Bedrock
+const BEDROCK_TOOL_BETA_MAP: Record<string, string> = {
+  bash_20250124: 'computer-use-2025-01-24',
+  bash_20241022: 'computer-use-2024-10-22',
+  text_editor_20250124: 'computer-use-2025-01-24',
+  text_editor_20241022: 'computer-use-2024-10-22',
+  text_editor_20250429: 'computer-use-2025-01-24',
+  text_editor_20250728: 'computer-use-2025-01-24',
+  computer_20250124: 'computer-use-2025-01-24',
+  computer_20241022: 'computer-use-2024-10-22',
+};
+
+export interface BedrockAnthropicProvider extends ProviderV3 {
+  /**
+Creates a model for text generation.
+*/
+  (modelId: BedrockAnthropicModelId): LanguageModelV3;
+
+  /**
+Creates a model for text generation.
+*/
+  languageModel(modelId: BedrockAnthropicModelId): LanguageModelV3;
+
+  /**
+Anthropic-specific computer use tool.
+   */
+  tools: typeof anthropicTools;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+export interface BedrockAnthropicProviderSettings {
+  /**
+The AWS region to use for the Bedrock provider. Defaults to the value of the
+`AWS_REGION` environment variable.
+   */
+  region?: string;
+
+  /**
+API key for authenticating requests using Bearer token authentication.
+When provided, this will be used instead of AWS SigV4 authentication.
+Defaults to the value of the `AWS_BEARER_TOKEN_BEDROCK` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+The AWS access key ID to use for the Bedrock provider. Defaults to the value of the
+`AWS_ACCESS_KEY_ID` environment variable.
+   */
+  accessKeyId?: string;
+
+  /**
+The AWS secret access key to use for the Bedrock provider. Defaults to the value of the
+`AWS_SECRET_ACCESS_KEY` environment variable.
+   */
+  secretAccessKey?: string;
+
+  /**
+The AWS session token to use for the Bedrock provider. Defaults to the value of the
+`AWS_SESSION_TOKEN` environment variable.
+   */
+  sessionToken?: string;
+
+  /**
+Base URL for the Bedrock API calls.
+   */
+  baseURL?: string;
+
+  /**
+Custom headers to include in the requests.
+   */
+  headers?: Resolvable<Record<string, string | undefined>>;
+
+  /**
+Custom fetch implementation. You can use it as a middleware to intercept requests,
+or to provide a custom fetch implementation for e.g. testing.
+*/
+  fetch?: FetchFunction;
+
+  /**
+The AWS credential provider to use for the Bedrock provider to get dynamic
+credentials similar to the AWS SDK. Setting a provider here will cause its
+credential values to be used instead of the `accessKeyId`, `secretAccessKey`,
+and `sessionToken` settings.
+   */
+  credentialProvider?: () => PromiseLike<Omit<BedrockCredentials, 'region'>>;
+}
+
+/**
+Create an Amazon Bedrock Anthropic provider instance.
+This provider uses the native Anthropic API through Bedrock's InvokeModel endpoint,
+bypassing the Converse API for better feature compatibility.
+ */
+export function createBedrockAnthropic(
+  options: BedrockAnthropicProviderSettings = {},
+): BedrockAnthropicProvider {
+  // Check for API key authentication first
+  const rawApiKey = loadOptionalSetting({
+    settingValue: options.apiKey,
+    environmentVariableName: 'AWS_BEARER_TOKEN_BEDROCK',
+  });
+
+  // Only use API key if it's a non-empty, non-whitespace string
+  const apiKey =
+    rawApiKey && rawApiKey.trim().length > 0 ? rawApiKey.trim() : undefined;
+
+  // Use API key authentication if available, otherwise fall back to SigV4
+  const baseFetchFunction = apiKey
+    ? createApiKeyFetchFunction(apiKey, options.fetch)
+    : createSigV4FetchFunction(async () => {
+        const region = loadSetting({
+          settingValue: options.region,
+          settingName: 'region',
+          environmentVariableName: 'AWS_REGION',
+          description: 'AWS region',
+        });
+
+        // If a credential provider is provided, use it to get the credentials.
+        if (options.credentialProvider) {
+          try {
+            return {
+              ...(await options.credentialProvider()),
+              region,
+            };
+          } catch (error) {
+            const errorMessage =
+              error instanceof Error ? error.message : String(error);
+            throw new Error(
+              `AWS credential provider failed: ${errorMessage}. ` +
+                'Please ensure your credential provider returns valid AWS credentials ' +
+                'with accessKeyId and secretAccessKey properties.',
+            );
+          }
+        }
+
+        try {
+          return {
+            region,
+            accessKeyId: loadSetting({
+              settingValue: options.accessKeyId,
+              settingName: 'accessKeyId',
+              environmentVariableName: 'AWS_ACCESS_KEY_ID',
+              description: 'AWS access key ID',
+            }),
+            secretAccessKey: loadSetting({
+              settingValue: options.secretAccessKey,
+              settingName: 'secretAccessKey',
+              environmentVariableName: 'AWS_SECRET_ACCESS_KEY',
+              description: 'AWS secret access key',
+            }),
+            sessionToken: loadOptionalSetting({
+              settingValue: options.sessionToken,
+              environmentVariableName: 'AWS_SESSION_TOKEN',
+            }),
+          };
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          if (
+            errorMessage.includes('AWS_ACCESS_KEY_ID') ||
+            errorMessage.includes('accessKeyId')
+          ) {
+            throw new Error(
+              'AWS SigV4 authentication requires AWS credentials. Please provide either:\n' +
+                '1. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables\n' +
+                '2. Provide accessKeyId and secretAccessKey in options\n' +
+                '3. Use a credentialProvider function\n' +
+                '4. Use API key authentication with AWS_BEARER_TOKEN_BEDROCK or apiKey option\n' +
+                `Original error: ${errorMessage}`,
+            );
+          }
+          if (
+            errorMessage.includes('AWS_SECRET_ACCESS_KEY') ||
+            errorMessage.includes('secretAccessKey')
+          ) {
+            throw new Error(
+              'AWS SigV4 authentication requires both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY. ' +
+                'Please ensure both credentials are provided.\n' +
+                `Original error: ${errorMessage}`,
+            );
+          }
+          throw error;
+        }
+      }, options.fetch);
+
+  // Wrap with Bedrock event stream to SSE transformer for streaming support
+  const fetchFunction = createBedrockAnthropicFetch(baseFetchFunction);
+
+  const getBaseURL = (): string =>
+    withoutTrailingSlash(
+      options.baseURL ??
+        `https://bedrock-runtime.${loadSetting({
+          settingValue: options.region,
+          settingName: 'region',
+          environmentVariableName: 'AWS_REGION',
+          description: 'AWS region',
+        })}.amazonaws.com`,
+    ) ?? 'https://bedrock-runtime.us-east-1.amazonaws.com';
+
+  const getHeaders = async () => {
+    const baseHeaders = (await resolve(options.headers)) ?? {};
+    return withUserAgentSuffix(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION}`);
+  };
+
+  const createChatModel = (modelId: BedrockAnthropicModelId) =>
+    new AnthropicMessagesLanguageModel(modelId, {
+      provider: 'bedrock.anthropic.messages',
+      baseURL: getBaseURL(),
+      headers: getHeaders,
+      fetch: fetchFunction,
+
+      buildRequestUrl: (baseURL, isStreaming) =>
+        `${baseURL}/model/${encodeURIComponent(modelId)}/${
+          isStreaming ? 'invoke-with-response-stream' : 'invoke'
+        }`,
+
+      transformRequestBody: args => {
+        const { model, stream, tool_choice, tools, ...rest } = args;
+
+        const transformedToolChoice =
+          tool_choice != null
+            ? {
+                type: tool_choice.type,
+                ...(tool_choice.name != null ? { name: tool_choice.name } : {}),
+              }
+            : undefined;
+
+        const requiredBetas = new Set<string>();
+        const transformedTools = tools?.map((tool: Record<string, unknown>) => {
+          const toolType = tool.type as string | undefined;
+
+          if (toolType && toolType in BEDROCK_TOOL_VERSION_MAP) {
+            const newType =
+              BEDROCK_TOOL_VERSION_MAP[
+                toolType as keyof typeof BEDROCK_TOOL_VERSION_MAP
+              ];
+            if (newType in BEDROCK_TOOL_BETA_MAP) {
+              requiredBetas.add(BEDROCK_TOOL_BETA_MAP[newType]);
+            }
+            const newName =
+              newType in BEDROCK_TOOL_NAME_MAP
+                ? BEDROCK_TOOL_NAME_MAP[newType]
+                : tool.name;
+            return {
+              ...tool,
+              type: newType,
+              name: newName,
+            };
+          }
+
+          if (toolType && toolType in BEDROCK_TOOL_BETA_MAP) {
+            requiredBetas.add(BEDROCK_TOOL_BETA_MAP[toolType]);
+          }
+
+          if (toolType && toolType in BEDROCK_TOOL_NAME_MAP) {
+            return {
+              ...tool,
+              name: BEDROCK_TOOL_NAME_MAP[toolType],
+            };
+          }
+
+          return tool;
+        });
+
+        return {
+          ...rest,
+          ...(transformedTools != null ? { tools: transformedTools } : {}),
+          ...(transformedToolChoice != null
+            ? { tool_choice: transformedToolChoice }
+            : {}),
+          ...(requiredBetas.size > 0
+            ? { anthropic_beta: Array.from(requiredBetas) }
+            : {}),
+          anthropic_version: 'bedrock-2023-05-31',
+        };
+      },
+
+      // Bedrock Anthropic doesn't support URL sources, force download and base64 conversion
+      supportedUrls: () => ({}),
+      // force the use of JSON tool fallback for structured outputs since beta header isn't supported
+      supportsNativeStructuredOutput: false,
+    });
+
+  const provider = function (modelId: BedrockAnthropicModelId) {
+    if (new.target) {
+      throw new Error(
+        'The Bedrock Anthropic model function cannot be called with the new keyword.',
+      );
+    }
+
+    return createChatModel(modelId);
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.messages = createChatModel;
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  provider.tools = anthropicTools;
+
+  return provider;
+}
+
+/**
+Default Bedrock Anthropic provider instance.
+ */
+export const bedrockAnthropic = createBedrockAnthropic();

package/src/anthropic/index.ts

@@ -0,0 +1,9 @@
+export {
+  bedrockAnthropic,
+  createBedrockAnthropic,
+} from './bedrock-anthropic-provider';
+export type {
+  BedrockAnthropicProvider,
+  BedrockAnthropicProviderSettings,
+} from './bedrock-anthropic-provider';
+export type { BedrockAnthropicModelId } from './bedrock-anthropic-options';

package/src/bedrock-api-types.ts

@@ -0,0 +1,195 @@
+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>;
+}
+
+export const BEDROCK_CACHE_POINT = {
+  cachePoint: { type: 'default' },
+} as const;
+
+export type BedrockCachePoint = { cachePoint: { type: 'default' } };
+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;
+    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;