@ai-sdk/google-vertex/dist/maas/edge/index.js

The **[Google Vertex provider](https://ai-sdk.dev/providers/ai-sdk-providers/google-vertex)** for the [AI SDK](https://ai-sdk.dev/docs) contains language model support for the [Google Vertex AI](https://cloud.google.com/vertex-ai) APIs.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/maas/edge/index.ts
var index_exports = {};
__export(index_exports, {
  createVertexMaas: () => createVertexMaas2,
  vertexMaas: () => vertexMaas
});
module.exports = __toCommonJS(index_exports);

// src/maas/edge/google-vertex-maas-provider-edge.ts
var import_provider_utils3 = require("@ai-sdk/provider-utils");

// src/edge/google-vertex-auth-edge.ts
var import_provider_utils = require("@ai-sdk/provider-utils");

// src/version.ts
var VERSION = true ? "4.0.137" : "0.0.0-test";

// src/edge/google-vertex-auth-edge.ts
var loadCredentials = async () => {
  try {
    return {
      clientEmail: (0, import_provider_utils.loadSetting)({
        settingValue: void 0,
        settingName: "clientEmail",
        environmentVariableName: "GOOGLE_CLIENT_EMAIL",
        description: "Google client email"
      }),
      privateKey: (0, import_provider_utils.loadSetting)({
        settingValue: void 0,
        settingName: "privateKey",
        environmentVariableName: "GOOGLE_PRIVATE_KEY",
        description: "Google private key"
      }),
      privateKeyId: (0, import_provider_utils.loadOptionalSetting)({
        settingValue: void 0,
        environmentVariableName: "GOOGLE_PRIVATE_KEY_ID"
      })
    };
  } catch (error) {
    throw new Error(`Failed to load Google credentials: ${error.message}`);
  }
};
var base64url = (str) => {
  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
};
var importPrivateKey = async (pemKey) => {
  const pemHeader = "-----BEGIN PRIVATE KEY-----";
  const pemFooter = "-----END PRIVATE KEY-----";
  const pemContents = pemKey.replace(pemHeader, "").replace(pemFooter, "").replace(/\s/g, "");
  const binaryString = atob(pemContents);
  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"]
  );
};
var buildJwt = async (credentials) => {
  const now = Math.floor(Date.now() / 1e3);
  const header = {
    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}`;
};
async function generateAuthToken(credentials) {
  try {
    const creds = credentials || await loadCredentials();
    const jwt = await buildJwt(creds);
    const response = await fetch("https://oauth2.googleapis.com/token", {
      method: "POST",
      headers: (0, import_provider_utils.withUserAgentSuffix)(
        { "Content-Type": "application/x-www-form-urlencoded" },
        `ai-sdk/google-vertex/${VERSION}`,
        (0, import_provider_utils.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;
  }
}

// src/maas/google-vertex-maas-provider.ts
var import_openai_compatible = require("@ai-sdk/openai-compatible");
var import_provider_utils2 = require("@ai-sdk/provider-utils");
function createVertexMaas(options = {}) {
  const loadLocation = () => (0, import_provider_utils2.loadOptionalSetting)({
    settingValue: options.location,
    environmentVariableName: "GOOGLE_VERTEX_LOCATION"
  });
  const loadProject = () => (0, import_provider_utils2.loadSetting)({
    settingValue: options.project,
    settingName: "project",
    environmentVariableName: "GOOGLE_VERTEX_PROJECT",
    description: "Google Vertex project"
  });
  const constructBaseURL = () => {
    var _a;
    const projectId = loadProject();
    const location = (_a = loadLocation()) != null ? _a : "global";
    return `https://aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/endpoints/openapi`;
  };
  const loadBaseURL = () => {
    var _a;
    return (0, import_provider_utils2.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : "") || constructBaseURL();
  };
  let cachedProvider;
  const getProvider = () => cachedProvider != null ? cachedProvider : cachedProvider = (0, import_openai_compatible.createOpenAICompatible)({
    name: "vertex.maas",
    baseURL: loadBaseURL(),
    fetch: options.fetch
  });
  const provider = (modelId) => getProvider()(modelId);
  provider.specificationVersion = "v3";
  provider.languageModel = (modelId) => getProvider().languageModel(modelId);
  provider.chatModel = (modelId) => getProvider().chatModel(modelId);
  provider.completionModel = (modelId) => getProvider().completionModel(modelId);
  provider.embeddingModel = (modelId) => getProvider().embeddingModel(modelId);
  provider.textEmbeddingModel = (modelId) => getProvider().textEmbeddingModel(modelId);
  provider.imageModel = (modelId) => getProvider().imageModel(modelId);
  return provider;
}

// src/maas/edge/google-vertex-maas-provider-edge.ts
function createVertexMaas2(options = {}) {
  const customFetch = async (url, init) => {
    var _a;
    const token = await generateAuthToken(options.googleCredentials);
    const resolvedHeaders = await (0, import_provider_utils3.resolve)(options.headers);
    const authHeaders = {
      ...resolvedHeaders,
      Authorization: `Bearer ${token}`
    };
    const fetchInit = {
      ...init,
      headers: {
        ...init == null ? void 0 : init.headers,
        ...authHeaders
      }
    };
    return ((_a = options.fetch) != null ? _a : fetch)(url, fetchInit);
  };
  return createVertexMaas({
    ...options,
    fetch: customFetch,
    headers: void 0
    // Don't pass headers, we handle them in fetch
  });
}
var vertexMaas = createVertexMaas2();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createVertexMaas,
  vertexMaas
});
//# sourceMappingURL=index.js.map