@ai-sdk/google-vertex/dist/xai/index.mjs

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.

// src/xai/google-vertex-xai-provider-node.ts
import { resolve } from "@ai-sdk/provider-utils";

// src/google-vertex-auth-google-auth-library.ts
import { GoogleAuth } from "google-auth-library";
function createAuthTokenGenerator(options) {
  const auth = new 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
import {
  NoSuchModelError
} from "@ai-sdk/provider";
import {
  createOpenAICompatible
} from "@ai-sdk/openai-compatible";
import {
  loadOptionalSetting,
  loadSetting,
  withoutTrailingSlash
} from "@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 = () => loadOptionalSetting({
    settingValue: options.location,
    environmentVariableName: "GOOGLE_VERTEX_LOCATION"
  });
  const loadProject = () => 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 withoutTrailingSlash((_a = options.baseURL) != null ? _a : "") || constructBaseURL();
  };
  let cachedProvider;
  const getProvider = () => cachedProvider != null ? cachedProvider : cachedProvider = 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 NoSuchModelError({ modelId, modelType: "embeddingModel" });
  };
  provider.textEmbeddingModel = provider.embeddingModel;
  provider.imageModel = (modelId) => {
    throw new 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 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();
export {
  createGoogleVertexXai2 as createGoogleVertexXai,
  googleVertexXai
};
//# sourceMappingURL=index.mjs.map