@ai-sdk/google-vertex/dist/xai/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/xai/index.ts
var index_exports = {};
__export(index_exports, {
  createGoogleVertexXai: () => createGoogleVertexXai2,
  googleVertexXai: () => googleVertexXai
});
module.exports = __toCommonJS(index_exports);

// src/xai/google-vertex-xai-provider-node.ts
var import_provider_utils2 = require("@ai-sdk/provider-utils");

// src/google-vertex-auth-google-auth-library.ts
var import_google_auth_library = require("google-auth-library");
function createAuthTokenGenerator(options) {
  const auth = new import_google_auth_library.GoogleAuth({
    scopes: ["https://www.googleapis.com/auth/cloud-platform"],
    ...options
  });
  return async function generateAuthToken() {
    var _a;
    const client = await auth.getClient();
    const token = await client.getAccessToken();
    return (_a = token == null ? void 0 : token.token) != null ? _a : null;
  };
}

// src/xai/google-vertex-xai-provider.ts
var import_provider = require("@ai-sdk/provider");
var import_openai_compatible = require("@ai-sdk/openai-compatible");
var import_provider_utils = require("@ai-sdk/provider-utils");
function convertGoogleVertexXaiUsage(usage) {
  var _a, _b, _c, _d, _e, _f;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a = usage.prompt_tokens) != null ? _a : 0;
  const completionTokens = (_b = usage.completion_tokens) != null ? _b : 0;
  const cacheReadTokens = (_d = (_c = usage.prompt_tokens_details) == null ? void 0 : _c.cached_tokens) != null ? _d : 0;
  const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cacheReadTokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens + reasoningTokens,
      text: completionTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function transformGoogleVertexXaiRequestBody(args) {
  const { reasoning_effort: _reasoningEffort, ...rest } = args;
  return rest;
}
function createGoogleVertexXai(options = {}) {
  const loadLocation = () => (0, import_provider_utils.loadOptionalSetting)({
    settingValue: options.location,
    environmentVariableName: "GOOGLE_VERTEX_LOCATION"
  });
  const loadProject = () => (0, import_provider_utils.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_utils.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : "") || constructBaseURL();
  };
  let cachedProvider;
  const getProvider = () => cachedProvider != null ? cachedProvider : cachedProvider = (0, import_openai_compatible.createOpenAICompatible)({
    name: "googleVertex.xai",
    baseURL: loadBaseURL(),
    fetch: options.fetch,
    includeUsage: true,
    supportsStructuredOutputs: true,
    supportedUrls: () => ({
      "image/*": [/^https?:\/\/.*$/]
    }),
    transformRequestBody: transformGoogleVertexXaiRequestBody,
    convertUsage: convertGoogleVertexXaiUsage
  });
  const createChatModel = (modelId) => getProvider().languageModel(modelId);
  const provider = function(modelId) {
    if (new.target) {
      throw new Error(
        "The Google Vertex xAI model function cannot be called with the new keyword."
      );
    }
    return createChatModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.languageModel = createChatModel;
  provider.chatModel = (modelId) => getProvider().chatModel(modelId);
  provider.embeddingModel = (modelId) => {
    throw new import_provider.NoSuchModelError({ modelId, modelType: "embeddingModel" });
  };
  provider.textEmbeddingModel = provider.embeddingModel;
  provider.imageModel = (modelId) => {
    throw new import_provider.NoSuchModelError({ modelId, modelType: "imageModel" });
  };
  return provider;
}

// src/xai/google-vertex-xai-provider-node.ts
function createGoogleVertexXai2(options = {}) {
  const generateAuthToken = createAuthTokenGenerator(options.googleAuthOptions);
  const customFetch = async (url, init) => {
    var _a;
    const token = await generateAuthToken();
    const resolvedHeaders = await (0, import_provider_utils2.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 createGoogleVertexXai({
    ...options,
    fetch: customFetch,
    headers: void 0
  });
}
var googleVertexXai = createGoogleVertexXai2();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createGoogleVertexXai,
  googleVertexXai
});
//# sourceMappingURL=index.js.map