@ai-sdk/amazon-bedrock 4.0.24 → 4.0.26

package/src/bedrock-sigv4-fetch.ts

@@ -0,0 +1,138 @@
+import {
+  FetchFunction,
+  combineHeaders,
+  normalizeHeaders,
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent,
+} from '@ai-sdk/provider-utils';
+import { AwsV4Signer } from 'aws4fetch';
+import { VERSION } from './version';
+
+export interface BedrockCredentials {
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string;
+}
+
+/**
+Creates a fetch function that applies AWS Signature Version 4 signing.
+
+@param getCredentials - Function that returns the AWS credentials to use when signing.
+@param fetch - Optional original fetch implementation to wrap. Defaults to global fetch.
+@returns A FetchFunction that signs requests before passing them to the underlying fetch.
+ */
+export function createSigV4FetchFunction(
+  getCredentials: () => BedrockCredentials | PromiseLike<BedrockCredentials>,
+  fetch: FetchFunction = globalThis.fetch,
+): FetchFunction {
+  return async (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    const request = input instanceof Request ? input : undefined;
+    const originalHeaders = combineHeaders(
+      normalizeHeaders(request?.headers),
+      normalizeHeaders(init?.headers),
+    );
+    const headersWithUserAgent = withUserAgentSuffix(
+      originalHeaders,
+      `ai-sdk/amazon-bedrock/${VERSION}`,
+      getRuntimeEnvironmentUserAgent(),
+    );
+
+    let effectiveBody: BodyInit | undefined = init?.body ?? undefined;
+    if (effectiveBody === undefined && request && request.body !== null) {
+      try {
+        effectiveBody = await request.clone().text();
+      } catch {}
+    }
+
+    const effectiveMethod = init?.method ?? request?.method;
+
+    if (effectiveMethod?.toUpperCase() !== 'POST' || !effectiveBody) {
+      return fetch(input, {
+        ...init,
+        headers: headersWithUserAgent as HeadersInit,
+      });
+    }
+
+    const url =
+      typeof input === 'string'
+        ? input
+        : input instanceof URL
+          ? input.href
+          : input.url;
+
+    const body = prepareBodyString(effectiveBody);
+    const credentials = await getCredentials();
+    const signer = new AwsV4Signer({
+      url,
+      method: 'POST',
+      headers: Object.entries(headersWithUserAgent),
+      body,
+      region: credentials.region,
+      accessKeyId: credentials.accessKeyId,
+      secretAccessKey: credentials.secretAccessKey,
+      sessionToken: credentials.sessionToken,
+      service: 'bedrock',
+    });
+
+    const signingResult = await signer.sign();
+    const signedHeaders = normalizeHeaders(signingResult.headers);
+
+    // Use the combined headers directly as HeadersInit
+    const combinedHeaders = combineHeaders(headersWithUserAgent, signedHeaders);
+
+    return fetch(input, {
+      ...init,
+      body,
+      headers: combinedHeaders as HeadersInit,
+    });
+  };
+}
+
+function prepareBodyString(body: BodyInit | undefined): string {
+  if (typeof body === 'string') {
+    return body;
+  } else if (body instanceof Uint8Array) {
+    return new TextDecoder().decode(body);
+  } else if (body instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(body));
+  } else {
+    return JSON.stringify(body);
+  }
+}
+
+/**
+Creates a fetch function that applies Bearer token authentication.
+
+@param apiKey - The API key to use for Bearer token authentication.
+@param fetch - Optional original fetch implementation to wrap. Defaults to global fetch.
+@returns A FetchFunction that adds Authorization header with Bearer token to requests.
+ */
+export function createApiKeyFetchFunction(
+  apiKey: string,
+  fetch: FetchFunction = globalThis.fetch,
+): FetchFunction {
+  return async (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    const originalHeaders = normalizeHeaders(init?.headers);
+    const headersWithUserAgent = withUserAgentSuffix(
+      originalHeaders,
+      `ai-sdk/amazon-bedrock/${VERSION}`,
+      getRuntimeEnvironmentUserAgent(),
+    );
+
+    const finalHeaders = combineHeaders(headersWithUserAgent, {
+      Authorization: `Bearer ${apiKey}`,
+    });
+
+    return fetch(input, {
+      ...init,
+      headers: finalHeaders as HeadersInit,
+    });
+  };
+}

package/src/convert-bedrock-usage.test.ts

@@ -0,0 +1,207 @@
+import { convertBedrockUsage } from './convert-bedrock-usage';
+import { describe, it, expect } from 'vitest';
+
+describe('convertBedrockUsage', () => {
+  it('should convert basic usage without cache tokens', () => {
+    const result = convertBedrockUsage({
+      inputTokens: 100,
+      outputTokens: 50,
+    });
+
+    expect(result).toEqual({
+      inputTokens: {
+        total: 100,
+        noCache: 100,
+        cacheRead: 0,
+        cacheWrite: 0,
+      },
+      outputTokens: {
+        total: 50,
+        text: 50,
+        reasoning: undefined,
+      },
+      raw: {
+        inputTokens: 100,
+        outputTokens: 50,
+      },
+    });
+  });
+
+  it('should convert usage with cache read tokens', () => {
+    const result = convertBedrockUsage({
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheReadInputTokens: 80,
+    });
+
+    expect(result).toEqual({
+      inputTokens: {
+        total: 180, // 100 + 80 + 0
+        noCache: 100,
+        cacheRead: 80,
+        cacheWrite: 0,
+      },
+      outputTokens: {
+        total: 50,
+        text: 50,
+        reasoning: undefined,
+      },
+      raw: {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheReadInputTokens: 80,
+      },
+    });
+  });
+
+  it('should convert usage with cache write tokens', () => {
+    const result = convertBedrockUsage({
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheWriteInputTokens: 60,
+    });
+
+    expect(result).toEqual({
+      inputTokens: {
+        total: 160, // 100 + 0 + 60
+        noCache: 100,
+        cacheRead: 0,
+        cacheWrite: 60,
+      },
+      outputTokens: {
+        total: 50,
+        text: 50,
+        reasoning: undefined,
+      },
+      raw: {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheWriteInputTokens: 60,
+      },
+    });
+  });
+
+  it('should convert usage with both cache read and write tokens', () => {
+    const result = convertBedrockUsage({
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheReadInputTokens: 80,
+      cacheWriteInputTokens: 60,
+    });
+
+    expect(result).toEqual({
+      inputTokens: {
+        total: 240, // 100 + 80 + 60
+        noCache: 100,
+        cacheRead: 80,
+        cacheWrite: 60,
+      },
+      outputTokens: {
+        total: 50,
+        text: 50,
+        reasoning: undefined,
+      },
+      raw: {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheReadInputTokens: 80,
+        cacheWriteInputTokens: 60,
+      },
+    });
+  });
+
+  it('should handle null cache tokens', () => {
+    const result = convertBedrockUsage({
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheReadInputTokens: null,
+      cacheWriteInputTokens: null,
+    });
+
+    expect(result).toEqual({
+      inputTokens: {
+        total: 100,
+        noCache: 100,
+        cacheRead: 0,
+        cacheWrite: 0,
+      },
+      outputTokens: {
+        total: 50,
+        text: 50,
+        reasoning: undefined,
+      },
+      raw: {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheReadInputTokens: null,
+        cacheWriteInputTokens: null,
+      },
+    });
+  });
+
+  it('should handle null usage', () => {
+    const result = convertBedrockUsage(null);
+
+    expect(result).toEqual({
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    });
+  });
+
+  it('should handle undefined usage', () => {
+    const result = convertBedrockUsage(undefined);
+
+    expect(result).toEqual({
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    });
+  });
+
+  it('should include totalTokens in raw when provided', () => {
+    const result = convertBedrockUsage({
+      inputTokens: 100,
+      outputTokens: 50,
+      totalTokens: 150,
+    });
+
+    expect(result.raw).toEqual({
+      inputTokens: 100,
+      outputTokens: 50,
+      totalTokens: 150,
+    });
+  });
+
+  it('should preserve raw usage data', () => {
+    const rawUsage = {
+      inputTokens: 100,
+      outputTokens: 50,
+      totalTokens: 150,
+      cacheReadInputTokens: 80,
+      cacheWriteInputTokens: 60,
+    };
+
+    const result = convertBedrockUsage(rawUsage);
+
+    expect(result.raw).toEqual(rawUsage);
+  });
+});

package/src/convert-bedrock-usage.ts

@@ -0,0 +1,50 @@
+import { LanguageModelV3Usage } from '@ai-sdk/provider';
+
+export type BedrockUsage = {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens?: number;
+  cacheReadInputTokens?: number | null;
+  cacheWriteInputTokens?: number | null;
+};
+
+export function convertBedrockUsage(
+  usage: BedrockUsage | undefined | null,
+): LanguageModelV3Usage {
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    };
+  }
+
+  const inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  const cacheReadTokens = usage.cacheReadInputTokens ?? 0;
+  const cacheWriteTokens = usage.cacheWriteInputTokens ?? 0;
+
+  return {
+    inputTokens: {
+      total: inputTokens + cacheReadTokens + cacheWriteTokens,
+      noCache: inputTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: cacheWriteTokens,
+    },
+    outputTokens: {
+      total: outputTokens,
+      text: outputTokens,
+      reasoning: undefined,
+    },
+    raw: usage,
+  };
+}