@ai-sdk/anthropic-aws 0.0.0 → 1.0.0

package/src/anthropic-aws-provider.ts

@@ -0,0 +1,262 @@
+import {
+  NoSuchModelError,
+  type LanguageModelV3,
+  type ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  loadOptionalSetting,
+  loadSetting,
+  withoutTrailingSlash,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import {
+  AnthropicMessagesLanguageModel,
+  anthropicTools,
+  type AnthropicMessagesModelId,
+} from '@ai-sdk/anthropic/internal';
+import {
+  createApiKeyFetchFunction,
+  createSigV4FetchFunction,
+  type AnthropicAwsCredentials,
+} from './anthropic-aws-fetch';
+
+export interface AnthropicAwsProvider extends ProviderV3 {
+  /**
+   * Creates a model for text generation.
+   */
+  (modelId: AnthropicMessagesModelId): LanguageModelV3;
+
+  /**
+   * Creates a model for text generation.
+   */
+  languageModel(modelId: AnthropicMessagesModelId): LanguageModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+
+  tools: typeof anthropicTools;
+}
+
+export interface AnthropicAwsProviderSettings {
+  /**
+   * The AWS region to use for Claude Platform on AWS. Defaults to the value of the
+   * `AWS_REGION` environment variable. Required — no fallback default.
+   */
+  region?: string;
+
+  /**
+   * The Anthropic workspace ID for this AWS account. Sent on every request via the
+   * `anthropic-workspace-id` header. Defaults to the value of the
+   * `ANTHROPIC_AWS_WORKSPACE_ID` environment variable.
+   */
+  workspaceId?: string;
+
+  /**
+   * API key for authenticating requests via the `x-api-key` header.
+   * When provided, this will be used instead of AWS SigV4 authentication.
+   * Defaults to the value of the `ANTHROPIC_AWS_API_KEY` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * The AWS access key ID to use for SigV4 authentication. Defaults to the value of the
+   * `AWS_ACCESS_KEY_ID` environment variable.
+   */
+  accessKeyId?: string;
+
+  /**
+   * The AWS secret access key to use for SigV4 authentication. Defaults to the value of the
+   * `AWS_SECRET_ACCESS_KEY` environment variable.
+   */
+  secretAccessKey?: string;
+
+  /**
+   * The AWS session token to use for SigV4 authentication. Defaults to the value of the
+   * `AWS_SESSION_TOKEN` environment variable.
+   */
+  sessionToken?: string;
+
+  /**
+   * Base URL for the Claude Platform on AWS API calls.
+   */
+  baseURL?: string;
+
+  /**
+   * Custom headers to include in the requests.
+   */
+  headers?: 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 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<AnthropicAwsCredentials, 'region'>
+  >;
+
+  generateId?: () => string;
+}
+
+/**
+ * Create a Claude Platform on AWS provider instance.
+ * This provider uses the Anthropic Messages API hosted in AWS, authenticated
+ * with AWS SigV4 or an AWS-provisioned API key.
+ */
+export function createAnthropicAws(
+  options: AnthropicAwsProviderSettings = {},
+): AnthropicAwsProvider {
+  const apiKey = loadOptionalSetting({
+    settingValue: options.apiKey,
+    environmentVariableName: 'ANTHROPIC_AWS_API_KEY',
+  });
+
+  const fetchFunction = apiKey
+    ? createApiKeyFetchFunction(apiKey, options.fetch)
+    : createSigV4FetchFunction(async () => {
+        const region = loadSetting({
+          settingValue: options.region,
+          settingName: 'region',
+          environmentVariableName: 'AWS_REGION',
+          description: 'AWS region',
+        });
+
+        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 ANTHROPIC_AWS_API_KEY 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);
+
+  const getBaseURL = (): string =>
+    withoutTrailingSlash(options.baseURL) ??
+    `https://aws-external-anthropic.${loadSetting({
+      settingValue: options.region,
+      settingName: 'region',
+      environmentVariableName: 'AWS_REGION',
+      description: 'AWS region',
+    })}.api.aws/v1`;
+
+  const getHeaders = (): Record<string, string | undefined> => ({
+    'anthropic-version': '2023-06-01',
+    'anthropic-workspace-id': loadSetting({
+      settingValue: options.workspaceId,
+      settingName: 'workspaceId',
+      environmentVariableName: 'ANTHROPIC_AWS_WORKSPACE_ID',
+      description: 'Anthropic AWS workspace ID',
+    }),
+    ...options.headers,
+  });
+
+  const createChatModel = (modelId: AnthropicMessagesModelId) =>
+    new AnthropicMessagesLanguageModel(modelId, {
+      provider: 'anthropic-aws.messages',
+      baseURL: getBaseURL(),
+      headers: getHeaders,
+      fetch: fetchFunction,
+      generateId: options.generateId,
+      supportedUrls: () => ({
+        'image/*': [/^https?:\/\/.*$/],
+        'application/pdf': [/^https?:\/\/.*$/],
+      }),
+    });
+
+  const provider = function (modelId: AnthropicMessagesModelId) {
+    if (new.target) {
+      throw new Error(
+        'The Anthropic AWS 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 Claude Platform on AWS provider instance.
+ */
+export const anthropicAws = createAnthropicAws();

package/src/index.ts

@@ -0,0 +1,7 @@
+export { anthropicAws, createAnthropicAws } from './anthropic-aws-provider';
+export type {
+  AnthropicAwsProvider,
+  AnthropicAwsProviderSettings,
+} from './anthropic-aws-provider';
+export type { AnthropicAwsCredentials } from './anthropic-aws-fetch';
+export { VERSION } from './version';

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';