@ai-sdk/google-vertex 4.0.23 → 4.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google-vertex",
-  "version": "4.0.23",
+  "version": "4.0.25",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,12 +8,17 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "docs/**/*",
+    "src",
     "CHANGELOG.md",
     "README.md",
     "edge.d.ts",
     "anthropic/edge.d.ts",
     "anthropic/index.d.ts"
   ],
+  "directories": {
+    "doc": "./docs"
+  },
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -39,8 +44,8 @@
   },
   "dependencies": {
     "google-auth-library": "^10.5.0",
-    "@ai-sdk/anthropic": "3.0.18",
-    "@ai-sdk/google": "3.0.10",
+    "@ai-sdk/anthropic": "3.0.20",
+    "@ai-sdk/google": "3.0.12",
     "@ai-sdk/provider": "3.0.4",
     "@ai-sdk/provider-utils": "4.0.8"
   },
@@ -49,7 +54,7 @@
     "tsup": "^8",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "1.0.1",
+    "@ai-sdk/test-server": "1.0.2",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
@@ -75,7 +80,7 @@
   "scripts": {
     "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
     "build:watch": "pnpm clean && tsup --watch",
-    "clean": "del-cli dist *.tsbuildinfo",
+    "clean": "del-cli dist docs *.tsbuildinfo",
     "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --build",
     "prettier-check": "prettier --check \"./**/*.ts*\"",

package/src/__snapshots__/google-vertex-embedding-model.test.ts.snap

@@ -0,0 +1,39 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`GoogleVertexEmbeddingModel > should expose the raw response 1`] = `
+{
+  "body": {
+    "predictions": [
+      {
+        "embeddings": {
+          "statistics": {
+            "token_count": 1,
+          },
+          "values": [
+            0.1,
+            0.2,
+            0.3,
+          ],
+        },
+      },
+      {
+        "embeddings": {
+          "statistics": {
+            "token_count": 1,
+          },
+          "values": [
+            0.4,
+            0.5,
+            0.6,
+          ],
+        },
+      },
+    ],
+  },
+  "headers": {
+    "content-length": "159",
+    "content-type": "application/json",
+    "test-header": "test-value",
+  },
+}
+`;

package/src/anthropic/edge/google-vertex-anthropic-provider-edge.test.ts

@@ -0,0 +1,87 @@
+import { resolve } from '@ai-sdk/provider-utils';
+import * as edgeAuth from '../../edge/google-vertex-auth-edge';
+import { createVertexAnthropic as createVertexAnthropicOriginal } from '../google-vertex-anthropic-provider';
+import { createVertexAnthropic as createVertexAnthropicEdge } from './google-vertex-anthropic-provider-edge';
+import { describe, beforeEach, expect, it, vi } from 'vitest';
+
+// Mock the imported modules
+vi.mock('../../edge/google-vertex-auth-edge', () => ({
+  generateAuthToken: vi.fn().mockResolvedValue('mock-auth-token'),
+}));
+
+vi.mock('../google-vertex-anthropic-provider', () => ({
+  createVertexAnthropic: vi.fn().mockImplementation(options => ({
+    ...options,
+  })),
+}));
+
+describe('google-vertex-anthropic-provider-edge', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('default headers function should return auth token', async () => {
+    createVertexAnthropicEdge({ project: 'test-project' });
+
+    const mockCreateVertex = vi.mocked(createVertexAnthropicOriginal);
+    const passedOptions = mockCreateVertex.mock.calls[0][0];
+
+    expect(mockCreateVertex).toHaveBeenCalledTimes(1);
+    expect(typeof passedOptions?.headers).toBe('function');
+
+    expect(await resolve(passedOptions?.headers)).toStrictEqual({
+      Authorization: 'Bearer mock-auth-token',
+    });
+  });
+
+  it('should use custom headers in addition to auth token when provided', async () => {
+    createVertexAnthropicEdge({
+      project: 'test-project',
+      headers: async () => ({
+        'Custom-Header': 'custom-value',
+      }),
+    });
+
+    const mockCreateVertex = vi.mocked(createVertexAnthropicOriginal);
+    const passedOptions = mockCreateVertex.mock.calls[0][0];
+
+    expect(mockCreateVertex).toHaveBeenCalledTimes(1);
+    expect(typeof passedOptions?.headers).toBe('function');
+    expect(await resolve(passedOptions?.headers)).toEqual({
+      Authorization: 'Bearer mock-auth-token',
+      'Custom-Header': 'custom-value',
+    });
+  });
+
+  it('should use edge auth token generator', async () => {
+    createVertexAnthropicEdge({ project: 'test-project' });
+
+    const mockCreateVertex = vi.mocked(createVertexAnthropicOriginal);
+    const passedOptions = mockCreateVertex.mock.calls[0][0];
+
+    // Verify the headers function actually calls generateAuthToken by checking its result
+    expect(passedOptions?.headers).toBeDefined();
+    await resolve(passedOptions?.headers);
+    expect(edgeAuth.generateAuthToken).toHaveBeenCalled();
+  });
+
+  it('passes googleCredentials to generateAuthToken', async () => {
+    createVertexAnthropicEdge({
+      project: 'test-project',
+      googleCredentials: {
+        clientEmail: 'test@example.com',
+        privateKey: 'test-key',
+      },
+    });
+
+    const mockCreateVertex = vi.mocked(createVertexAnthropicOriginal);
+    const passedOptions = mockCreateVertex.mock.calls[0][0];
+
+    await resolve(passedOptions?.headers); // call the headers function
+
+    expect(edgeAuth.generateAuthToken).toHaveBeenCalledWith({
+      clientEmail: 'test@example.com',
+      privateKey: 'test-key',
+    });
+  });
+});

package/src/anthropic/edge/google-vertex-anthropic-provider-edge.ts

@@ -0,0 +1,41 @@
+import { resolve } from '@ai-sdk/provider-utils';
+import {
+  generateAuthToken,
+  GoogleCredentials,
+} from '../../edge/google-vertex-auth-edge';
+import {
+  createVertexAnthropic as createVertexAnthropicOriginal,
+  GoogleVertexAnthropicProvider,
+  GoogleVertexAnthropicProviderSettings as GoogleVertexAnthropicProviderSettingsOriginal,
+} from '../google-vertex-anthropic-provider';
+
+export type { GoogleVertexAnthropicProvider };
+
+export interface GoogleVertexAnthropicProviderSettings
+  extends GoogleVertexAnthropicProviderSettingsOriginal {
+  /**
+   * Optional. The Google credentials for the Google Cloud service account. If
+   * not provided, the Google Vertex provider will use environment variables to
+   * load the credentials.
+   */
+  googleCredentials?: GoogleCredentials;
+}
+
+export function createVertexAnthropic(
+  options: GoogleVertexAnthropicProviderSettings = {},
+): GoogleVertexAnthropicProvider {
+  return createVertexAnthropicOriginal({
+    ...options,
+    headers: async () => ({
+      Authorization: `Bearer ${await generateAuthToken(
+        options.googleCredentials,
+      )}`,
+      ...(await resolve(options.headers)),
+    }),
+  });
+}
+
+/**
+ * Default Google Vertex AI Anthropic provider instance.
+ */
+export const vertexAnthropic = createVertexAnthropic();

package/src/anthropic/edge/index.ts

@@ -0,0 +1,8 @@
+export {
+  createVertexAnthropic,
+  vertexAnthropic,
+} from './google-vertex-anthropic-provider-edge';
+export type {
+  GoogleVertexAnthropicProviderSettings,
+  GoogleVertexAnthropicProvider,
+} from './google-vertex-anthropic-provider-edge';

package/src/anthropic/google-vertex-anthropic-messages-options.ts

@@ -0,0 +1,15 @@
+// https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/claude
+export type GoogleVertexAnthropicMessagesModelId =
+  | 'claude-opus-4-5@20251101'
+  | 'claude-sonnet-4-5@20250929'
+  | 'claude-opus-4-1@20250805'
+  | 'claude-opus-4@20250514'
+  | 'claude-sonnet-4@20250514'
+  | 'claude-3-7-sonnet@20250219'
+  | 'claude-3-5-sonnet-v2@20241022'
+  | 'claude-3-5-haiku@20241022'
+  | 'claude-3-5-sonnet@20240620'
+  | 'claude-3-haiku@20240307'
+  | 'claude-3-sonnet@20240229'
+  | 'claude-3-opus@20240229'
+  | (string & {});

package/src/anthropic/google-vertex-anthropic-provider-node.test.ts

@@ -0,0 +1,73 @@
+import { resolve } from '@ai-sdk/provider-utils';
+import { createVertexAnthropic as createVertexAnthropicOriginal } from './google-vertex-anthropic-provider';
+import { createVertexAnthropic as createVertexAnthropicNode } from './google-vertex-anthropic-provider-node';
+import { generateAuthToken } from '../google-vertex-auth-google-auth-library';
+import { describe, beforeEach, expect, it, vi } from 'vitest';
+
+// Mock the imported modules
+vi.mock('../google-vertex-auth-google-auth-library', () => ({
+  generateAuthToken: vi.fn().mockResolvedValue('mock-auth-token'),
+}));
+
+vi.mock('./google-vertex-anthropic-provider', () => ({
+  createVertexAnthropic: vi.fn().mockImplementation(options => ({
+    ...options,
+  })),
+}));
+
+describe('google-vertex-anthropic-provider-node', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('default headers function should return auth token', async () => {
+    createVertexAnthropicNode({ project: 'test-project' });
+
+    expect(createVertexAnthropicOriginal).toHaveBeenCalledTimes(1);
+    const passedOptions = vi.mocked(createVertexAnthropicOriginal).mock
+      .calls[0][0];
+
+    expect(typeof passedOptions?.headers).toBe('function');
+    expect(await resolve(passedOptions?.headers)).toStrictEqual({
+      Authorization: 'Bearer mock-auth-token',
+    });
+  });
+
+  it('should use custom headers in addition to auth token when provided', async () => {
+    createVertexAnthropicNode({
+      project: 'test-project',
+      headers: async () => ({
+        'Custom-Header': 'custom-value',
+      }),
+    });
+
+    expect(createVertexAnthropicOriginal).toHaveBeenCalledTimes(1);
+    const passedOptions = vi.mocked(createVertexAnthropicOriginal).mock
+      .calls[0][0];
+
+    expect(await resolve(passedOptions?.headers)).toEqual({
+      Authorization: 'Bearer mock-auth-token',
+      'Custom-Header': 'custom-value',
+    });
+  });
+
+  it('passes googleAuthOptions to generateAuthToken', async () => {
+    createVertexAnthropicNode({
+      googleAuthOptions: {
+        scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+        keyFile: 'path/to/key.json',
+      },
+    });
+
+    expect(createVertexAnthropicOriginal).toHaveBeenCalledTimes(1);
+    const passedOptions = vi.mocked(createVertexAnthropicOriginal).mock
+      .calls[0][0];
+
+    await resolve(passedOptions?.headers); // call the headers function
+
+    expect(generateAuthToken).toHaveBeenCalledWith({
+      scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+      keyFile: 'path/to/key.json',
+    });
+  });
+});

package/src/anthropic/google-vertex-anthropic-provider-node.ts

@@ -0,0 +1,40 @@
+import { resolve } from '@ai-sdk/provider-utils';
+import { GoogleAuthOptions } from 'google-auth-library';
+import { generateAuthToken } from '../google-vertex-auth-google-auth-library';
+import {
+  createVertexAnthropic as createVertexAnthropicOriginal,
+  GoogleVertexAnthropicProvider,
+  GoogleVertexAnthropicProviderSettings as GoogleVertexAnthropicProviderSettingsOriginal,
+} from './google-vertex-anthropic-provider';
+
+export type { GoogleVertexAnthropicProvider };
+
+export interface GoogleVertexAnthropicProviderSettings
+  extends GoogleVertexAnthropicProviderSettingsOriginal {
+  /**
+ Optional. The Authentication options provided by google-auth-library.
+Complete list of authentication options is documented in the
+GoogleAuthOptions interface:
+https://github.com/googleapis/google-auth-library-nodejs/blob/main/src/auth/googleauth.ts.
+   */
+  googleAuthOptions?: GoogleAuthOptions;
+}
+
+export function createVertexAnthropic(
+  options: GoogleVertexAnthropicProviderSettings = {},
+): GoogleVertexAnthropicProvider {
+  return createVertexAnthropicOriginal({
+    ...options,
+    headers: async () => ({
+      Authorization: `Bearer ${await generateAuthToken(
+        options.googleAuthOptions,
+      )}`,
+      ...(await resolve(options.headers)),
+    }),
+  });
+}
+
+/**
+Default Google Vertex Anthropic provider instance.
+ */
+export const vertexAnthropic = createVertexAnthropic();

package/src/anthropic/google-vertex-anthropic-provider.test.ts

@@ -0,0 +1,208 @@
+import {
+  createVertexAnthropic,
+  vertexAnthropicTools,
+} from './google-vertex-anthropic-provider';
+import { NoSuchModelError } from '@ai-sdk/provider';
+import { AnthropicMessagesLanguageModel } from '@ai-sdk/anthropic/internal';
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+
+// Mock the imported modules
+vi.mock('@ai-sdk/provider-utils', () => ({
+  loadOptionalSetting: vi
+    .fn()
+    .mockImplementation(({ settingValue }) => settingValue),
+  withoutTrailingSlash: vi.fn().mockImplementation(url => url),
+  createJsonErrorResponseHandler: vi.fn(),
+  createProviderToolFactory: vi.fn(),
+  createProviderToolFactoryWithOutputSchema: vi.fn(),
+  lazySchema: vi.fn(),
+  zodSchema: vi.fn(),
+}));
+
+vi.mock('@ai-sdk/anthropic/internal', async () => {
+  const originalModule = await vi.importActual('@ai-sdk/anthropic/internal');
+  return {
+    ...originalModule,
+    AnthropicMessagesLanguageModel: vi.fn(),
+  };
+});
+
+describe('google-vertex-anthropic-provider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create a language model with default settings', () => {
+    const provider = createVertexAnthropic({
+      project: 'test-project',
+      location: 'test-location',
+    });
+    provider('test-model-id');
+
+    // Assert that the model constructor was called with the correct arguments
+    expect(AnthropicMessagesLanguageModel).toHaveBeenCalledWith(
+      'test-model-id',
+      expect.objectContaining({
+        baseURL: expect.stringContaining(
+          '/projects/test-project/locations/test-location/publishers/anthropic/models',
+        ),
+        provider: 'vertex.anthropic.messages',
+        headers: expect.any(Object),
+        buildRequestUrl: expect.any(Function),
+        transformRequestBody: expect.any(Function),
+      }),
+    );
+  });
+
+  it('should throw an error when using new keyword', () => {
+    const provider = createVertexAnthropic({ project: 'test-project' });
+
+    expect(() => new (provider as any)('test-model-id')).toThrow(
+      'The Anthropic model function cannot be called with the new keyword.',
+    );
+  });
+
+  it('should pass baseURL to the model when created', () => {
+    const customBaseURL = 'https://custom-url.com';
+    const provider = createVertexAnthropic({
+      project: 'test-project',
+      baseURL: customBaseURL,
+    });
+    provider('test-model-id');
+
+    // Assert that the constructor was called with the correct baseURL
+    expect(AnthropicMessagesLanguageModel).toHaveBeenCalledWith(
+      expect.anything(), // modelId
+      expect.objectContaining({
+        baseURL: customBaseURL,
+      }),
+    );
+  });
+
+  it('should throw NoSuchModelError for textEmbeddingModel', () => {
+    const provider = createVertexAnthropic({ project: 'test-project' });
+
+    expect(() => provider.embeddingModel('invalid-model-id')).toThrow(
+      NoSuchModelError,
+    );
+  });
+
+  it('should include vertexAnthropicTools (subset of anthropicTools)', () => {
+    const provider = createVertexAnthropic({ project: 'test-project' });
+
+    expect(provider.tools).toBe(vertexAnthropicTools);
+    expect(provider.tools).toHaveProperty('bash_20241022');
+    expect(provider.tools).toHaveProperty('bash_20250124');
+    expect(provider.tools).toHaveProperty('textEditor_20241022');
+    expect(provider.tools).toHaveProperty('textEditor_20250124');
+    expect(provider.tools).toHaveProperty('textEditor_20250429');
+    expect(provider.tools).toHaveProperty('textEditor_20250728');
+    expect(provider.tools).toHaveProperty('computer_20241022');
+    expect(provider.tools).toHaveProperty('webSearch_20250305');
+    expect(provider.tools).not.toHaveProperty('codeExecution_20250825');
+  });
+
+  it('should pass custom headers to the model constructor', () => {
+    const customHeaders = { 'Custom-Header': 'custom-value' };
+    const provider = createVertexAnthropic({
+      project: 'test-project',
+      headers: customHeaders,
+    });
+    provider('test-model-id');
+
+    // Assert that the model constructor was called with the correct headers
+    expect(AnthropicMessagesLanguageModel).toHaveBeenCalledWith(
+      expect.anything(), // modelId
+      expect.objectContaining({
+        headers: customHeaders,
+      }),
+    );
+  });
+
+  it('should create a Google Vertex Anthropic provider instance with custom settings', () => {
+    const customProvider = createVertexAnthropic({
+      project: 'custom-project',
+      location: 'custom-location',
+      baseURL: 'https://custom.base.url',
+      headers: { 'Custom-Header': 'value' },
+    });
+
+    expect(customProvider).toBeDefined();
+    expect(typeof customProvider).toBe('function');
+    expect(customProvider.languageModel).toBeDefined();
+  });
+
+  it('should not support URL sources to force base64 conversion', () => {
+    const provider = createVertexAnthropic();
+    provider('test-model-id');
+
+    // Assert that the model constructor was called with supportedUrls function
+    expect(AnthropicMessagesLanguageModel).toHaveBeenCalledWith(
+      'test-model-id',
+      expect.objectContaining({
+        supportedUrls: expect.any(Function),
+      }),
+    );
+
+    // Get the actual config passed to the constructor
+    const constructorCall = vi.mocked(AnthropicMessagesLanguageModel).mock
+      .calls[vi.mocked(AnthropicMessagesLanguageModel).mock.calls.length - 1];
+    const config = constructorCall[1];
+
+    // Verify that supportedUrls returns empty object to force base64 conversion
+    expect(config.supportedUrls?.()).toEqual({});
+  });
+
+  it('should use correct URL for global location', () => {
+    const provider = createVertexAnthropic({
+      project: 'test-project',
+      location: 'global',
+    });
+    provider('test-model-id');
+
+    expect(AnthropicMessagesLanguageModel).toHaveBeenCalledWith(
+      'test-model-id',
+      expect.objectContaining({
+        baseURL:
+          'https://aiplatform.googleapis.com/v1/projects/test-project/locations/global/publishers/anthropic/models',
+        provider: 'vertex.anthropic.messages',
+      }),
+    );
+  });
+
+  it('should use region-prefixed URL for non-global locations', () => {
+    const provider = createVertexAnthropic({
+      project: 'test-project',
+      location: 'us-east5',
+    });
+    provider('test-model-id');
+
+    expect(AnthropicMessagesLanguageModel).toHaveBeenCalledWith(
+      'test-model-id',
+      expect.objectContaining({
+        baseURL:
+          'https://us-east5-aiplatform.googleapis.com/v1/projects/test-project/locations/us-east5/publishers/anthropic/models',
+        provider: 'vertex.anthropic.messages',
+      }),
+    );
+  });
+
+  it('should support combining tools with structured outputs (inherited from Anthropic)', () => {
+    const provider = createVertexAnthropic({
+      project: 'test-project',
+      location: 'us-east5',
+    });
+
+    // Create a model instance
+    const model = provider('claude-3-5-sonnet-v2@20241022');
+
+    // Verify the model was created using AnthropicMessagesLanguageModel
+    // which already supports combining tools with structured outputs
+    expect(AnthropicMessagesLanguageModel).toHaveBeenCalledWith(
+      'claude-3-5-sonnet-v2@20241022',
+      expect.objectContaining({
+        provider: 'vertex.anthropic.messages',
+      }),
+    );
+  });
+});