@ai-sdk/google-vertex 4.0.23 → 4.0.25

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

@@ -0,0 +1,210 @@
+import {
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  Resolvable,
+  loadOptionalSetting,
+  withoutTrailingSlash,
+} from '@ai-sdk/provider-utils';
+import {
+  anthropicTools,
+  AnthropicMessagesLanguageModel,
+} from '@ai-sdk/anthropic/internal';
+import { GoogleVertexAnthropicMessagesModelId } from './google-vertex-anthropic-messages-options';
+
+/**
+ * Tools supported by Google Vertex Anthropic.
+ * This is a subset of the full Anthropic tools - only these are recognized by the Vertex API.
+ */
+export const vertexAnthropicTools = {
+  /**
+   * The bash tool enables Claude to execute shell commands in a persistent bash session,
+   * allowing system operations, script execution, and command-line automation.
+   *
+   * Image results are supported.
+   */
+  bash_20241022: anthropicTools.bash_20241022,
+
+  /**
+   * The bash tool enables Claude to execute shell commands in a persistent bash session,
+   * allowing system operations, script execution, and command-line automation.
+   *
+   * Image results are supported.
+   */
+  bash_20250124: anthropicTools.bash_20250124,
+
+  /**
+   * Claude can use an Anthropic-defined text editor tool to view and modify text files,
+   * helping you debug, fix, and improve your code or other text documents.
+   *
+   * Supported models: Claude Sonnet 3.5
+   */
+  textEditor_20241022: anthropicTools.textEditor_20241022,
+
+  /**
+   * Claude can use an Anthropic-defined text editor tool to view and modify text files,
+   * helping you debug, fix, and improve your code or other text documents.
+   *
+   * Supported models: Claude Sonnet 3.7
+   */
+  textEditor_20250124: anthropicTools.textEditor_20250124,
+
+  /**
+   * Claude can use an Anthropic-defined text editor tool to view and modify text files.
+   * Note: This version does not support the "undo_edit" command.
+   * @deprecated Use textEditor_20250728 instead
+   */
+  textEditor_20250429: anthropicTools.textEditor_20250429,
+
+  /**
+   * Claude can use an Anthropic-defined text editor tool to view and modify text files.
+   * Note: This version does not support the "undo_edit" command and adds optional max_characters parameter.
+   * Supported models: Claude Sonnet 4, Opus 4, and Opus 4.1
+   */
+  textEditor_20250728: anthropicTools.textEditor_20250728,
+
+  /**
+   * Claude can interact with computer environments through the computer use tool, which
+   * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
+   *
+   * Image results are supported.
+   */
+  computer_20241022: anthropicTools.computer_20241022,
+
+  /**
+   * Creates a web search tool that gives Claude direct access to real-time web content.
+   */
+  webSearch_20250305: anthropicTools.webSearch_20250305,
+};
+export interface GoogleVertexAnthropicProvider extends ProviderV3 {
+  /**
+Creates a model for text generation.
+*/
+  (modelId: GoogleVertexAnthropicMessagesModelId): LanguageModelV3;
+
+  /**
+Creates a model for text generation.
+*/
+  languageModel(modelId: GoogleVertexAnthropicMessagesModelId): LanguageModelV3;
+
+  /**
+   * Anthropic tools supported by Google Vertex.
+   * Note: Only a subset of Anthropic tools are available on Vertex.
+   * Supported tools: bash_20241022, bash_20250124, textEditor_20241022,
+   * textEditor_20250124, textEditor_20250429, textEditor_20250728,
+   * computer_20241022, webSearch_20250305
+   */
+  tools: typeof vertexAnthropicTools;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+export interface GoogleVertexAnthropicProviderSettings {
+  /**
+   * Google Cloud project ID. Defaults to the value of the `GOOGLE_VERTEX_PROJECT` environment variable.
+   */
+  project?: string;
+
+  /**
+   * Google Cloud region. Defaults to the value of the `GOOGLE_VERTEX_LOCATION` environment variable.
+   */
+  location?: string;
+
+  /**
+Use a different URL prefix for API calls, e.g. to use proxy servers.
+The default prefix is `https://api.anthropic.com/v1`.
+   */
+  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;
+}
+
+/**
+Create a Google Vertex Anthropic provider instance.
+ */
+export function createVertexAnthropic(
+  options: GoogleVertexAnthropicProviderSettings = {},
+): GoogleVertexAnthropicProvider {
+  const getBaseURL = () => {
+    const location = loadOptionalSetting({
+      settingValue: options.location,
+      environmentVariableName: 'GOOGLE_VERTEX_LOCATION',
+    });
+    const project = loadOptionalSetting({
+      settingValue: options.project,
+      environmentVariableName: 'GOOGLE_VERTEX_PROJECT',
+    });
+
+    return (
+      withoutTrailingSlash(options.baseURL) ??
+      `https://${location === 'global' ? '' : location + '-'}aiplatform.googleapis.com/v1/projects/${project}/locations/${location}/publishers/anthropic/models`
+    );
+  };
+
+  const createChatModel = (modelId: GoogleVertexAnthropicMessagesModelId) =>
+    new AnthropicMessagesLanguageModel(modelId, {
+      provider: 'vertex.anthropic.messages',
+      baseURL: getBaseURL(),
+      headers: options.headers ?? {},
+      fetch: options.fetch,
+
+      buildRequestUrl: (baseURL, isStreaming) =>
+        `${baseURL}/${modelId}:${
+          isStreaming ? 'streamRawPredict' : 'rawPredict'
+        }`,
+      transformRequestBody: args => {
+        // Remove model from args and add anthropic version
+        const { model, ...rest } = args;
+        return {
+          ...rest,
+          anthropic_version: 'vertex-2023-10-16',
+        };
+      },
+      // Google Vertex 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: GoogleVertexAnthropicMessagesModelId) {
+    if (new.target) {
+      throw new Error(
+        'The 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 = vertexAnthropicTools;
+
+  return provider;
+}

package/src/anthropic/index.ts

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

package/src/edge/google-vertex-auth-edge.test.ts

@@ -0,0 +1,308 @@
+import {
+  generateAuthToken,
+  GoogleCredentials,
+} from './google-vertex-auth-edge';
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
+
+// Mock provider-utils to control runtime environment detection
+vi.mock('@ai-sdk/provider-utils', async () => {
+  const actual = await vi.importActual('@ai-sdk/provider-utils');
+  return {
+    ...actual,
+    getRuntimeEnvironmentUserAgent: vi.fn(() => 'runtime/testenv'),
+    withUserAgentSuffix: actual.withUserAgentSuffix,
+  };
+});
+
+vi.mock('../version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+describe('Google Vertex Edge Auth', () => {
+  const mockCredentials: GoogleCredentials = {
+    clientEmail: 'test@test.iam.gserviceaccount.com',
+    privateKey: 'mock-private-key',
+    privateKeyId: 'test-key-id',
+  };
+
+  const setupAtobStub = (credentials: typeof mockCredentials) => {
+    vi.stubGlobal(
+      'atob',
+      vi.fn().mockImplementation(str => {
+        const payload = {
+          alg: 'RS256',
+          typ: 'JWT',
+          iss: credentials.clientEmail,
+          scope: 'https://www.googleapis.com/auth/cloud-platform',
+          aud: 'https://oauth2.googleapis.com/token',
+          iat: 1616161616,
+          exp: 1616165216,
+        };
+
+        if (credentials.privateKeyId) {
+          Object.assign(payload, { kid: credentials.privateKeyId });
+        }
+
+        return JSON.stringify(payload);
+      }),
+    );
+  };
+
+  beforeEach(() => {
+    // Mock WebCrypto
+    const mockSubtleCrypto = {
+      importKey: vi.fn().mockResolvedValue('mock-crypto-key'),
+      sign: vi.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
+    };
+
+    const mockCrypto = {
+      subtle: mockSubtleCrypto,
+    };
+
+    // Use vi.stubGlobal instead of direct assignment
+    vi.stubGlobal('crypto', mockCrypto);
+
+    // Mock fetch
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ access_token: 'mock.jwt.token' }),
+    });
+
+    setupAtobStub(mockCredentials);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it('should generate a valid JWT token', async () => {
+    // Mock successful token exchange
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          access_token:
+            'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6InRlc3Qta2V5LWlkIn0.eyJpc3MiOiJ0ZXN0QHRlc3QuaWFtLmdzZXJ2aWNlYWNjb3VudC5jb20iLCJzY29wZSI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2xvdWQtcGxhdGZvcm0iLCJhdWQiOiJodHRwczovL29hdXRoMi5nb29nbGVhcGlzLmNvbS90b2tlbiIsImlhdCI6MTYxNjE2MTYxNiwiZXhwIjoxNjE2MTY1MjE2fQ.signature',
+        }),
+    });
+
+    const token = await generateAuthToken(mockCredentials);
+
+    // JWT structure validation
+    const parts = token.split('.');
+    expect(parts).toHaveLength(3);
+
+    // Header validation
+    const header = JSON.parse(atob(parts[0]));
+    expect(header).toMatchObject({
+      alg: 'RS256',
+      typ: 'JWT',
+      kid: mockCredentials.privateKeyId,
+      iss: mockCredentials.clientEmail,
+    });
+
+    // Payload validation
+    const payload = JSON.parse(atob(parts[1]));
+    expect(payload).toHaveProperty('iss', mockCredentials.clientEmail);
+    expect(payload).toHaveProperty(
+      'scope',
+      'https://www.googleapis.com/auth/cloud-platform',
+    );
+    expect(payload).toHaveProperty(
+      'aud',
+      'https://oauth2.googleapis.com/token',
+    );
+    expect(payload).toHaveProperty('iat');
+    expect(payload).toHaveProperty('exp');
+
+    // Verify exp is ~1 hour after iat
+    expect(payload.exp - payload.iat).toBe(3600);
+  });
+
+  it('should throw error with invalid credentials', async () => {
+    // Mock failed token exchange
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 400,
+      statusText: 'Bad Request',
+      json: () => Promise.resolve({ error: 'invalid_grant' }),
+    });
+
+    const invalidCredentials = {
+      ...mockCredentials,
+      private_key: 'invalid-key',
+    };
+
+    await expect(generateAuthToken(invalidCredentials)).rejects.toThrow(
+      'Token request failed: Bad Request',
+    );
+  });
+
+  it('should load credentials from environment variables', async () => {
+    process.env.GOOGLE_CLIENT_EMAIL = mockCredentials.clientEmail;
+    process.env.GOOGLE_PRIVATE_KEY = mockCredentials.privateKey;
+    process.env.GOOGLE_PRIVATE_KEY_ID = mockCredentials.privateKeyId;
+
+    // Mock successful token exchange
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ access_token: 'mock.jwt.token' }),
+    });
+
+    const token = await generateAuthToken();
+    expect(token).toBeTruthy();
+    expect(token.split('.')).toHaveLength(3);
+
+    // Clean up
+    delete process.env.GOOGLE_CLIENT_EMAIL;
+    delete process.env.GOOGLE_PRIVATE_KEY;
+    delete process.env.GOOGLE_PRIVATE_KEY_ID;
+  });
+
+  it('should throw error when client email is missing', async () => {
+    delete process.env.GOOGLE_CLIENT_EMAIL;
+    process.env.GOOGLE_PRIVATE_KEY = mockCredentials.privateKey;
+    process.env.GOOGLE_PRIVATE_KEY_ID = mockCredentials.privateKeyId;
+
+    await expect(generateAuthToken()).rejects.toThrow(
+      "Google client email setting is missing. Pass it using the 'clientEmail' parameter or the GOOGLE_CLIENT_EMAIL environment variable.",
+    );
+
+    // Clean up
+    delete process.env.GOOGLE_PRIVATE_KEY;
+    delete process.env.GOOGLE_PRIVATE_KEY_ID;
+  });
+
+  it('should throw error when private key is missing', async () => {
+    process.env.GOOGLE_CLIENT_EMAIL = mockCredentials.clientEmail;
+    delete process.env.GOOGLE_PRIVATE_KEY;
+    process.env.GOOGLE_PRIVATE_KEY_ID = mockCredentials.privateKeyId;
+
+    await expect(generateAuthToken()).rejects.toThrow(
+      "Google private key setting is missing. Pass it using the 'privateKey' parameter or the GOOGLE_PRIVATE_KEY environment variable.",
+    );
+
+    // Clean up
+    delete process.env.GOOGLE_CLIENT_EMAIL;
+    delete process.env.GOOGLE_PRIVATE_KEY_ID;
+  });
+
+  it('should work with or without private key ID', async () => {
+    // Test with private key ID
+    process.env.GOOGLE_CLIENT_EMAIL = mockCredentials.clientEmail;
+    process.env.GOOGLE_PRIVATE_KEY = mockCredentials.privateKey;
+    process.env.GOOGLE_PRIVATE_KEY_ID = mockCredentials.privateKeyId;
+
+    // Mock successful token exchange
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ access_token: 'mock.jwt.token' }),
+    });
+
+    const tokenWithKeyId = await generateAuthToken();
+    expect(tokenWithKeyId).toBeTruthy();
+
+    // Test without private key ID
+    delete process.env.GOOGLE_PRIVATE_KEY_ID;
+
+    const tokenWithoutKeyId = await generateAuthToken();
+    expect(tokenWithoutKeyId).toBeTruthy();
+
+    // Clean up
+    delete process.env.GOOGLE_CLIENT_EMAIL;
+    delete process.env.GOOGLE_PRIVATE_KEY;
+  });
+
+  it('should handle newlines in private key from env vars', async () => {
+    process.env.GOOGLE_CLIENT_EMAIL = mockCredentials.clientEmail;
+    process.env.GOOGLE_PRIVATE_KEY = mockCredentials.privateKey.replace(
+      /\n/g,
+      '\\n',
+    );
+    process.env.GOOGLE_PRIVATE_KEY_ID = mockCredentials.privateKeyId;
+
+    // Mock successful token exchange
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ access_token: 'mock.jwt.token' }),
+    });
+
+    const token = await generateAuthToken();
+    expect(token).toBeTruthy();
+
+    // Clean up
+    delete process.env.GOOGLE_CLIENT_EMAIL;
+    delete process.env.GOOGLE_PRIVATE_KEY;
+    delete process.env.GOOGLE_PRIVATE_KEY_ID;
+  });
+
+  it('should throw error on fetch failure', async () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
+
+    await expect(generateAuthToken(mockCredentials)).rejects.toThrow(
+      'Network error',
+    );
+
+    consoleSpy.mockRestore();
+  });
+
+  it('should throw error when token request fails', async () => {
+    // Mock a failed response from the token endpoint
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      statusText: 'Unauthorized',
+      status: 401,
+      json: () => Promise.resolve({ error: 'unauthorized' }),
+    });
+
+    await expect(generateAuthToken(mockCredentials)).rejects.toThrow(
+      'Token request failed: Unauthorized',
+    );
+  });
+
+  it('should work without privateKeyId', async () => {
+    const credentialsWithoutKeyId = {
+      clientEmail: mockCredentials.clientEmail,
+      privateKey: mockCredentials.privateKey,
+    };
+    setupAtobStub(credentialsWithoutKeyId);
+
+    // Mock successful token exchange
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ access_token: 'mock.jwt.token' }),
+    });
+
+    const token = await generateAuthToken(credentialsWithoutKeyId);
+    expect(token).toBeTruthy();
+
+    // Verify the JWT structure
+    const parts = token.split('.');
+    expect(parts).toHaveLength(3);
+
+    // Verify header doesn't include kid when privateKeyId is not provided
+    const header = JSON.parse(atob(parts[0]));
+    expect(header).not.toHaveProperty('kid');
+  });
+
+  it('should include correct user-agent header', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ access_token: 'mock.jwt.token' }),
+    });
+    global.fetch = mockFetch;
+
+    await generateAuthToken(mockCredentials);
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://oauth2.googleapis.com/token',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'user-agent': 'ai-sdk/google-vertex/0.0.0-test runtime/testenv',
+        }),
+      }),
+    );
+  });
+});

package/src/edge/google-vertex-auth-edge.ts

@@ -0,0 +1,161 @@
+import {
+  loadOptionalSetting,
+  loadSetting,
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from '../version';
+
+export interface GoogleCredentials {
+  /**
+   * The client email for the Google Cloud service account. Defaults to the
+   * value of the `GOOGLE_CLIENT_EMAIL` environment variable.
+   */
+  clientEmail: string;
+
+  /**
+   * The private key for the Google Cloud service account. Defaults to the
+   * value of the `GOOGLE_PRIVATE_KEY` environment variable.
+   */
+  privateKey: string;
+
+  /**
+   * Optional. The private key ID for the Google Cloud service account. Defaults
+   * to the value of the `GOOGLE_PRIVATE_KEY_ID` environment variable.
+   */
+  privateKeyId?: string;
+}
+
+const loadCredentials = async (): Promise<GoogleCredentials> => {
+  try {
+    return {
+      clientEmail: loadSetting({
+        settingValue: undefined,
+        settingName: 'clientEmail',
+        environmentVariableName: 'GOOGLE_CLIENT_EMAIL',
+        description: 'Google client email',
+      }),
+      privateKey: loadSetting({
+        settingValue: undefined,
+        settingName: 'privateKey',
+        environmentVariableName: 'GOOGLE_PRIVATE_KEY',
+        description: 'Google private key',
+      }),
+      privateKeyId: loadOptionalSetting({
+        settingValue: undefined,
+        environmentVariableName: 'GOOGLE_PRIVATE_KEY_ID',
+      }),
+    };
+  } catch (error: any) {
+    throw new Error(`Failed to load Google credentials: ${error.message}`);
+  }
+};
+
+// Convert a string to base64url
+const base64url = (str: string) => {
+  return btoa(str).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+};
+const importPrivateKey = async (pemKey: string) => {
+  const pemHeader = '-----BEGIN PRIVATE KEY-----';
+  const pemFooter = '-----END PRIVATE KEY-----';
+
+  // Remove header, footer, and any whitespace/newlines
+  const pemContents = pemKey
+    .replace(pemHeader, '')
+    .replace(pemFooter, '')
+    .replace(/\s/g, '');
+
+  // Decode base64 to binary
+  const binaryString = atob(pemContents);
+
+  // Convert binary string to Uint8Array
+  const binaryData = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    binaryData[i] = binaryString.charCodeAt(i);
+  }
+
+  return await crypto.subtle.importKey(
+    'pkcs8',
+    binaryData,
+    { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
+    true,
+    ['sign'],
+  );
+};
+
+const buildJwt = async (credentials: GoogleCredentials) => {
+  const now = Math.floor(Date.now() / 1000);
+
+  // Only include kid in header if privateKeyId is provided
+  const header: { alg: string; typ: string; kid?: string } = {
+    alg: 'RS256',
+    typ: 'JWT',
+  };
+
+  if (credentials.privateKeyId) {
+    header.kid = credentials.privateKeyId;
+  }
+
+  const payload = {
+    iss: credentials.clientEmail,
+    scope: 'https://www.googleapis.com/auth/cloud-platform',
+    aud: 'https://oauth2.googleapis.com/token',
+    exp: now + 3600,
+    iat: now,
+  };
+
+  const privateKey = await importPrivateKey(credentials.privateKey);
+
+  const signingInput = `${base64url(JSON.stringify(header))}.${base64url(
+    JSON.stringify(payload),
+  )}`;
+  const encoder = new TextEncoder();
+  const data = encoder.encode(signingInput);
+
+  const signature = await crypto.subtle.sign(
+    'RSASSA-PKCS1-v1_5',
+    privateKey,
+    data,
+  );
+
+  const signatureBase64 = base64url(
+    String.fromCharCode(...new Uint8Array(signature)),
+  );
+
+  return `${base64url(JSON.stringify(header))}.${base64url(
+    JSON.stringify(payload),
+  )}.${signatureBase64}`;
+};
+
+/**
+ * Generate an authentication token for Google Vertex AI in a manner compatible
+ * with the Edge runtime.
+ */
+export async function generateAuthToken(credentials?: GoogleCredentials) {
+  try {
+    const creds = credentials || (await loadCredentials());
+    const jwt = await buildJwt(creds);
+
+    const response = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: withUserAgentSuffix(
+        { 'Content-Type': 'application/x-www-form-urlencoded' },
+        `ai-sdk/google-vertex/${VERSION}`,
+        getRuntimeEnvironmentUserAgent(),
+      ),
+      body: new URLSearchParams({
+        grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+        assertion: jwt,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Token request failed: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data.access_token;
+  } catch (error) {
+    throw error;
+  }
+}