langchain 0.0.147 → 0.0.148

package/dist/load/serializable.js

@@ -134,11 +134,30 @@ export class Serializable {
         }
         // include all secrets used, even if not in kwargs,
         // will be replaced with sentinel value in replaceSecrets
-        for (const key in secrets) {
-            if (key in this && this[key] !== undefined) {
-                kwargs[key] = this[key] || kwargs[key];
+        Object.keys(secrets).forEach((keyPath) => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias, @typescript-eslint/no-explicit-any
+            let read = this;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let write = kwargs;
+            const [last, ...partsReverse] = keyPath.split(".").reverse();
+            for (const key of partsReverse.reverse()) {
+                if (!(key in read) || read[key] === undefined)
+                    return;
+                if (!(key in write) || write[key] === undefined) {
+                    if (typeof read[key] === "object" && read[key] != null) {
+                        write[key] = {};
+                    }
+                    else if (Array.isArray(read[key])) {
+                        write[key] = [];
+                    }
+                }
+                read = read[key];
+                write = write[key];
             }
-        }
+            if (last in read && read[last] !== undefined) {
+                write[last] = write[last] || read[last];
+            }
+        });
         return {
             lc: 1,
             type: "constructor",

package/dist/retrievers/multi_query.cjs

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiQueryRetriever = void 0;
+const llm_chain_js_1 = require("../chains/llm_chain.cjs");
+const prompt_js_1 = require("../prompts/prompt.cjs");
+const output_parser_js_1 = require("../schema/output_parser.cjs");
+const retriever_js_1 = require("../schema/retriever.cjs");
+class LineListOutputParser extends output_parser_js_1.BaseOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "retrievers", "multiquery"]
+        });
+    }
+    static lc_name() {
+        return "LineListOutputParser";
+    }
+    async parse(text) {
+        const startKeyIndex = text.indexOf("<questions>");
+        const endKeyIndex = text.indexOf("</questions>");
+        const questionsStartIndex = startKeyIndex === -1 ? 0 : startKeyIndex + "<questions>".length;
+        const questionsEndIndex = endKeyIndex === -1 ? text.length : endKeyIndex;
+        const lines = text
+            .slice(questionsStartIndex, questionsEndIndex)
+            .trim()
+            .split("\n")
+            .filter((line) => line.trim() !== "");
+        return { lines };
+    }
+    getFormatInstructions() {
+        throw new Error("Not implemented.");
+    }
+}
+// Create template
+const DEFAULT_QUERY_PROMPT = /* #__PURE__ */ new prompt_js_1.PromptTemplate({
+    inputVariables: ["question", "queryCount"],
+    template: `You are an AI language model assistant. Your task is
+to generate {queryCount} different versions of the given user
+question to retrieve relevant documents from a vector database.
+By generating multiple perspectives on the user question,
+your goal is to help the user overcome some of the limitations
+of distance-based similarity search.
+
+Provide these alternative questions separated by newlines between XML tags. For example:
+
+<questions>
+Question 1
+Question 2
+Question 3
+</questions>
+
+Original question: {question}`,
+});
+// Export class
+class MultiQueryRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "MultiQueryRetriever";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "retrievers", "multiquery"]
+        });
+        Object.defineProperty(this, "retriever", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llmChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3
+        });
+        Object.defineProperty(this, "parserKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "lines"
+        });
+        this.retriever = fields.retriever;
+        this.llmChain = fields.llmChain;
+        this.queryCount = fields.queryCount ?? this.queryCount;
+        this.parserKey = fields.parserKey ?? this.parserKey;
+    }
+    static fromLLM(fields) {
+        const { retriever, llm, prompt = DEFAULT_QUERY_PROMPT, queryCount, parserKey, ...rest } = fields;
+        const outputParser = new LineListOutputParser();
+        const llmChain = new llm_chain_js_1.LLMChain({ llm, prompt, outputParser });
+        return new this({ retriever, llmChain, queryCount, parserKey, ...rest });
+    }
+    // Generate the different queries for each retrieval, using our llmChain
+    async _generateQueries(question, runManager) {
+        const response = await this.llmChain.call({ question, queryCount: this.queryCount }, runManager?.getChild());
+        const lines = response.text[this.parserKey] || [];
+        if (this.verbose) {
+            console.log(`Generated queries: ${lines}`);
+        }
+        return lines;
+    }
+    // Retrieve documents using the original retriever
+    async _retrieveDocuments(queries, runManager) {
+        const documents = [];
+        for (const query of queries) {
+            const docs = await this.retriever.getRelevantDocuments(query, runManager?.getChild());
+            documents.push(...docs);
+        }
+        return documents;
+    }
+    // Deduplicate the documents that were returned in multiple retrievals
+    _uniqueUnion(documents) {
+        const uniqueDocumentsDict = {};
+        for (const doc of documents) {
+            const key = `${doc.pageContent}:${JSON.stringify(Object.entries(doc.metadata).sort())}`;
+            uniqueDocumentsDict[key] = doc;
+        }
+        const uniqueDocuments = Object.values(uniqueDocumentsDict);
+        return uniqueDocuments;
+    }
+    async _getRelevantDocuments(question, runManager) {
+        const queries = await this._generateQueries(question, runManager);
+        const documents = await this._retrieveDocuments(queries, runManager);
+        const uniqueDocuments = this._uniqueUnion(documents);
+        return uniqueDocuments;
+    }
+}
+exports.MultiQueryRetriever = MultiQueryRetriever;

package/dist/retrievers/multi_query.d.ts

@@ -0,0 +1,33 @@
+import { LLMChain } from "../chains/llm_chain.js";
+import { Document } from "../document.js";
+import { BaseRetriever, BaseRetrieverInput } from "../schema/retriever.js";
+import { CallbackManagerForRetrieverRun } from "../callbacks/index.js";
+import { BaseLanguageModel } from "../base_language/index.js";
+import { BasePromptTemplate } from "../prompts/base.js";
+interface LineList {
+    lines: string[];
+}
+export interface MultiQueryRetrieverInput extends BaseRetrieverInput {
+    retriever: BaseRetriever;
+    llmChain: LLMChain<LineList>;
+    queryCount?: number;
+    parserKey?: string;
+}
+export declare class MultiQueryRetriever extends BaseRetriever {
+    static lc_name(): string;
+    lc_namespace: string[];
+    private retriever;
+    private llmChain;
+    private queryCount;
+    private parserKey;
+    constructor(fields: MultiQueryRetrieverInput);
+    static fromLLM(fields: Omit<MultiQueryRetrieverInput, "llmChain"> & {
+        llm: BaseLanguageModel;
+        prompt?: BasePromptTemplate;
+    }): MultiQueryRetriever;
+    private _generateQueries;
+    private _retrieveDocuments;
+    private _uniqueUnion;
+    _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;
+}
+export {};

package/dist/retrievers/multi_query.js

@@ -0,0 +1,136 @@
+import { LLMChain } from "../chains/llm_chain.js";
+import { PromptTemplate } from "../prompts/prompt.js";
+import { BaseOutputParser } from "../schema/output_parser.js";
+import { BaseRetriever } from "../schema/retriever.js";
+class LineListOutputParser extends BaseOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "retrievers", "multiquery"]
+        });
+    }
+    static lc_name() {
+        return "LineListOutputParser";
+    }
+    async parse(text) {
+        const startKeyIndex = text.indexOf("<questions>");
+        const endKeyIndex = text.indexOf("</questions>");
+        const questionsStartIndex = startKeyIndex === -1 ? 0 : startKeyIndex + "<questions>".length;
+        const questionsEndIndex = endKeyIndex === -1 ? text.length : endKeyIndex;
+        const lines = text
+            .slice(questionsStartIndex, questionsEndIndex)
+            .trim()
+            .split("\n")
+            .filter((line) => line.trim() !== "");
+        return { lines };
+    }
+    getFormatInstructions() {
+        throw new Error("Not implemented.");
+    }
+}
+// Create template
+const DEFAULT_QUERY_PROMPT = /* #__PURE__ */ new PromptTemplate({
+    inputVariables: ["question", "queryCount"],
+    template: `You are an AI language model assistant. Your task is
+to generate {queryCount} different versions of the given user
+question to retrieve relevant documents from a vector database.
+By generating multiple perspectives on the user question,
+your goal is to help the user overcome some of the limitations
+of distance-based similarity search.
+
+Provide these alternative questions separated by newlines between XML tags. For example:
+
+<questions>
+Question 1
+Question 2
+Question 3
+</questions>
+
+Original question: {question}`,
+});
+// Export class
+export class MultiQueryRetriever extends BaseRetriever {
+    static lc_name() {
+        return "MultiQueryRetriever";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "retrievers", "multiquery"]
+        });
+        Object.defineProperty(this, "retriever", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llmChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3
+        });
+        Object.defineProperty(this, "parserKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "lines"
+        });
+        this.retriever = fields.retriever;
+        this.llmChain = fields.llmChain;
+        this.queryCount = fields.queryCount ?? this.queryCount;
+        this.parserKey = fields.parserKey ?? this.parserKey;
+    }
+    static fromLLM(fields) {
+        const { retriever, llm, prompt = DEFAULT_QUERY_PROMPT, queryCount, parserKey, ...rest } = fields;
+        const outputParser = new LineListOutputParser();
+        const llmChain = new LLMChain({ llm, prompt, outputParser });
+        return new this({ retriever, llmChain, queryCount, parserKey, ...rest });
+    }
+    // Generate the different queries for each retrieval, using our llmChain
+    async _generateQueries(question, runManager) {
+        const response = await this.llmChain.call({ question, queryCount: this.queryCount }, runManager?.getChild());
+        const lines = response.text[this.parserKey] || [];
+        if (this.verbose) {
+            console.log(`Generated queries: ${lines}`);
+        }
+        return lines;
+    }
+    // Retrieve documents using the original retriever
+    async _retrieveDocuments(queries, runManager) {
+        const documents = [];
+        for (const query of queries) {
+            const docs = await this.retriever.getRelevantDocuments(query, runManager?.getChild());
+            documents.push(...docs);
+        }
+        return documents;
+    }
+    // Deduplicate the documents that were returned in multiple retrievals
+    _uniqueUnion(documents) {
+        const uniqueDocumentsDict = {};
+        for (const doc of documents) {
+            const key = `${doc.pageContent}:${JSON.stringify(Object.entries(doc.metadata).sort())}`;
+            uniqueDocumentsDict[key] = doc;
+        }
+        const uniqueDocuments = Object.values(uniqueDocumentsDict);
+        return uniqueDocuments;
+    }
+    async _getRelevantDocuments(question, runManager) {
+        const queries = await this._generateQueries(question, runManager);
+        const documents = await this._retrieveDocuments(queries, runManager);
+        const uniqueDocuments = this._uniqueUnion(documents);
+        return uniqueDocuments;
+    }
+}

package/dist/types/googlevertexai-types.d.ts

@@ -1,9 +1,8 @@
-import { GoogleAuthOptions } from "google-auth-library";
 import { BaseLLMParams } from "../llms/base.js";
-export interface GoogleVertexAIConnectionParams {
+export interface GoogleVertexAIConnectionParams<AuthOptions> {
     /** Hostname for the API call */
     endpoint?: string;
-    authOptions?: GoogleAuthOptions;
+    authOptions?: AuthOptions;
     /** Region where the LLM is stored */
     location?: string;
     /** The version of the API functions. Part of the path. */
@@ -39,7 +38,7 @@ export interface GoogleVertexAIModelParams {
      */
     topK?: number;
 }
-export interface GoogleVertexAIBaseLLMInput extends BaseLLMParams, GoogleVertexAIConnectionParams, GoogleVertexAIModelParams {
+export interface GoogleVertexAIBaseLLMInput<AuthOptions> extends BaseLLMParams, GoogleVertexAIConnectionParams<AuthOptions>, GoogleVertexAIModelParams {
 }
 export interface GoogleVertexAIResponse {
     data: any;
@@ -52,3 +51,11 @@ export interface GoogleVertexAILLMResponse<PredictionType extends GoogleVertexAI
         predictions: PredictionType[];
     };
 }
+export interface GoogleVertexAIAbstractedClient {
+    request: (opts: {
+        url?: string;
+        method?: "GET" | "POST";
+        data?: unknown;
+    }) => unknown;
+    getProjectId: () => Promise<string>;
+}

package/dist/util/googlevertexai-connection.cjs

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleVertexAILLMConnection = exports.GoogleVertexAIConnection = void 0;
-const google_auth_library_1 = require("google-auth-library");
 class GoogleVertexAIConnection {
-    constructor(fields, caller) {
+    constructor(fields, caller, client) {
         Object.defineProperty(this, "caller", {
             enumerable: true,
             configurable: true,
@@ -28,7 +27,7 @@ class GoogleVertexAIConnection {
             writable: true,
             value: "v1"
         });
-        Object.defineProperty(this, "auth", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -38,16 +37,12 @@ class GoogleVertexAIConnection {
         this.endpoint = fields?.endpoint ?? this.endpoint;
         this.location = fields?.location ?? this.location;
         this.apiVersion = fields?.apiVersion ?? this.apiVersion;
-        this.auth = new google_auth_library_1.GoogleAuth({
-            scopes: "https://www.googleapis.com/auth/cloud-platform",
-            ...fields?.authOptions,
-        });
+        this.client = client;
     }
     buildMethod() {
         return "POST";
     }
     async _request(data, options) {
-        const client = await this.auth.getClient();
         const url = await this.buildUrl();
         const method = this.buildMethod();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -58,11 +53,8 @@ class GoogleVertexAIConnection {
         if (data && method === "POST") {
             opts.data = data;
         }
-        async function _request() {
-            return client.request(opts);
-        }
         try {
-            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, _request.bind(client));
+            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
             const response = callResponse; // Done for typecast safety, I guess
             return response;
         }
@@ -74,18 +66,25 @@ class GoogleVertexAIConnection {
 }
 exports.GoogleVertexAIConnection = GoogleVertexAIConnection;
 class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
-    constructor(fields, caller) {
-        super(fields, caller);
+    constructor(fields, caller, client) {
+        super(fields, caller, client);
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.client = client;
         this.model = fields?.model ?? this.model;
     }
     async buildUrl() {
-        const projectId = await this.auth.getProjectId();
+        const projectId = await this.client.getProjectId();
         const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
         return url;
     }

package/dist/util/googlevertexai-connection.d.ts

@@ -1,21 +1,21 @@
-import { GoogleAuth } from "google-auth-library";
 import { BaseLanguageModelCallOptions } from "../base_language/index.js";
 import { AsyncCaller, AsyncCallerCallOptions } from "./async_caller.js";
-import { GoogleVertexAIBaseLLMInput, GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMResponse, GoogleVertexAIModelParams, GoogleVertexAIResponse } from "../types/googlevertexai-types.js";
-export declare abstract class GoogleVertexAIConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleVertexAIResponse> implements GoogleVertexAIConnectionParams {
+import type { GoogleVertexAIBaseLLMInput, GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMResponse, GoogleVertexAIModelParams, GoogleVertexAIResponse, GoogleVertexAIAbstractedClient } from "../types/googlevertexai-types.js";
+export declare abstract class GoogleVertexAIConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleVertexAIResponse, AuthOptions> implements GoogleVertexAIConnectionParams<AuthOptions> {
     caller: AsyncCaller;
     endpoint: string;
     location: string;
     apiVersion: string;
-    auth: GoogleAuth;
-    constructor(fields: GoogleVertexAIConnectionParams | undefined, caller: AsyncCaller);
+    client: GoogleVertexAIAbstractedClient;
+    constructor(fields: GoogleVertexAIConnectionParams<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleVertexAIAbstractedClient);
     abstract buildUrl(): Promise<string>;
     buildMethod(): string;
     _request(data: unknown | undefined, options: CallOptions): Promise<ResponseType>;
 }
-export declare class GoogleVertexAILLMConnection<CallOptions extends BaseLanguageModelCallOptions, InstanceType, PredictionType extends GoogleVertexAIBasePrediction> extends GoogleVertexAIConnection<CallOptions, PredictionType> implements GoogleVertexAIBaseLLMInput {
+export declare class GoogleVertexAILLMConnection<CallOptions extends BaseLanguageModelCallOptions, InstanceType, PredictionType extends GoogleVertexAIBasePrediction, AuthOptions> extends GoogleVertexAIConnection<CallOptions, PredictionType, AuthOptions> implements GoogleVertexAIBaseLLMInput<AuthOptions> {
     model: string;
-    constructor(fields: GoogleVertexAIBaseLLMInput | undefined, caller: AsyncCaller);
+    client: GoogleVertexAIAbstractedClient;
+    constructor(fields: GoogleVertexAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleVertexAIAbstractedClient);
     buildUrl(): Promise<string>;
     request(instances: InstanceType[], parameters: GoogleVertexAIModelParams, options: CallOptions): Promise<GoogleVertexAILLMResponse<PredictionType>>;
 }

package/dist/util/googlevertexai-connection.js

@@ -1,6 +1,5 @@
-import { GoogleAuth } from "google-auth-library";
 export class GoogleVertexAIConnection {
-    constructor(fields, caller) {
+    constructor(fields, caller, client) {
         Object.defineProperty(this, "caller", {
             enumerable: true,
             configurable: true,
@@ -25,7 +24,7 @@ export class GoogleVertexAIConnection {
             writable: true,
             value: "v1"
         });
-        Object.defineProperty(this, "auth", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -35,16 +34,12 @@ export class GoogleVertexAIConnection {
         this.endpoint = fields?.endpoint ?? this.endpoint;
         this.location = fields?.location ?? this.location;
         this.apiVersion = fields?.apiVersion ?? this.apiVersion;
-        this.auth = new GoogleAuth({
-            scopes: "https://www.googleapis.com/auth/cloud-platform",
-            ...fields?.authOptions,
-        });
+        this.client = client;
     }
     buildMethod() {
         return "POST";
     }
     async _request(data, options) {
-        const client = await this.auth.getClient();
         const url = await this.buildUrl();
         const method = this.buildMethod();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -55,11 +50,8 @@ export class GoogleVertexAIConnection {
         if (data && method === "POST") {
             opts.data = data;
         }
-        async function _request() {
-            return client.request(opts);
-        }
         try {
-            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, _request.bind(client));
+            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
             const response = callResponse; // Done for typecast safety, I guess
             return response;
         }
@@ -70,18 +62,25 @@ export class GoogleVertexAIConnection {
     }
 }
 export class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
-    constructor(fields, caller) {
-        super(fields, caller);
+    constructor(fields, caller, client) {
+        super(fields, caller, client);
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.client = client;
         this.model = fields?.model ?? this.model;
     }
     async buildUrl() {
-        const projectId = await this.auth.getProjectId();
+        const projectId = await this.client.getProjectId();
         const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
         return url;
     }

package/dist/util/googlevertexai-webauth.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGoogleAuth = void 0;
+const google_1 = require("web-auth-library/google");
+const env_js_1 = require("./env.cjs");
+class WebGoogleAuth {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const credentials = options?.credentials ??
+            (0, env_js_1.getEnvironmentVariable)("GOOGLE_VERTEX_AI_WEB_CREDENTIALS");
+        if (credentials === undefined)
+            throw new Error(`Credentials not found. Please set the GOOGLE_VERTEX_AI_WEB_CREDENTIALS or pass credentials into "authOptions.credentials".`);
+        const scope = options?.scope ?? "https://www.googleapis.com/auth/cloud-platform";
+        this.options = { ...options, credentials, scope };
+    }
+    async getProjectId() {
+        const credentials = (0, google_1.getCredentials)(this.options.credentials);
+        return credentials.project_id;
+    }
+    async request(opts) {
+        const accessToken = await (0, google_1.getAccessToken)(this.options);
+        if (opts.url == null)
+            throw new Error("Missing URL");
+        const fetchOptions = {
+            method: opts.method,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        };
+        if (opts.data !== undefined) {
+            fetchOptions.body = JSON.stringify(opts.data);
+        }
+        const res = await fetch(opts.url, fetchOptions);
+        if (!res.ok) {
+            const error = new Error(`Could not get access token for Vertex AI with status code: ${res.status}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.response = res;
+            throw error;
+        }
+        return {
+            data: await res.json(),
+            config: {},
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+            request: { responseURL: res.url },
+        };
+    }
+}
+exports.WebGoogleAuth = WebGoogleAuth;

package/dist/util/googlevertexai-webauth.d.ts

@@ -0,0 +1,25 @@
+import { Credentials } from "web-auth-library/google";
+import type { GoogleVertexAIAbstractedClient } from "../types/googlevertexai-types.js";
+export type WebGoogleAuthOptions = {
+    credentials: string | Credentials;
+    scope?: string | string[];
+};
+export declare class WebGoogleAuth implements GoogleVertexAIAbstractedClient {
+    options: WebGoogleAuthOptions;
+    constructor(options?: WebGoogleAuthOptions);
+    getProjectId(): Promise<string>;
+    request(opts: {
+        url?: string;
+        method?: string;
+        data?: unknown;
+    }): Promise<{
+        data: any;
+        config: {};
+        status: number;
+        statusText: string;
+        headers: Headers;
+        request: {
+            responseURL: string;
+        };
+    }>;
+}