langchain 0.0.78 → 0.0.80

package/dist/llms/googlevertexai.cjs

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleVertexAI = void 0;
+const base_js_1 = require("./base.cjs");
+const googlevertexai_connection_js_1 = require("../util/googlevertexai-connection.cjs");
+/**
+ * Enables calls to the Google Cloud's Vertex AI API to access
+ * Large Language Models.
+ *
+ * To use, you will need to have one of the following authentication
+ * methods in place:
+ * - You are logged into an account permitted to the Google Cloud project
+ *   using Vertex AI.
+ * - You are running this on a machine using a service account permitted to
+ *   the Google Cloud project using Vertex AI.
+ * - The `GOOGLE_APPLICATION_CREDENTIALS` environment variable is set to the
+ *   path of a credentials file for a service account permitted to the
+ *   Google Cloud project using Vertex AI.
+ */
+class GoogleVertexAI extends base_js_1.BaseLLM {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text-bison"
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.7
+        });
+        Object.defineProperty(this, "maxOutputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1024
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.8
+        });
+        Object.defineProperty(this, "topK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 40
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields?.model ?? this.model;
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxOutputTokens = fields?.maxOutputTokens ?? this.maxOutputTokens;
+        this.topP = fields?.topP ?? this.topP;
+        this.topK = fields?.topK ?? this.topK;
+        this.connection = new googlevertexai_connection_js_1.GoogleVertexAIConnection({ ...fields, ...this }, this.caller);
+    }
+    _llmType() {
+        return "googlevertexai";
+    }
+    async _generate(prompts, options) {
+        const generations = await Promise.all(prompts.map((prompt) => this._generatePrompt(prompt, options)));
+        return { generations };
+    }
+    async _generatePrompt(prompt, options) {
+        const instance = this.formatInstance(prompt);
+        const parameters = {
+            temperature: this.temperature,
+            topK: this.topK,
+            topP: this.topP,
+            maxOutputTokens: this.maxOutputTokens,
+        };
+        const result = await this.connection.request([instance], parameters, options);
+        const prediction = this.extractPredictionFromResponse(result);
+        return [
+            {
+                text: prediction.content,
+                generationInfo: prediction,
+            },
+        ];
+    }
+    formatInstance(prompt) {
+        return { content: prompt };
+    }
+    extractPredictionFromResponse(result) {
+        return result?.data?.predictions[0];
+    }
+}
+exports.GoogleVertexAI = GoogleVertexAI;

package/dist/llms/googlevertexai.d.ts

@@ -0,0 +1,43 @@
+import { BaseLLM } from "./base.js";
+import { Generation, LLMResult } from "../schema/index.js";
+import { GoogleVertexAIBaseLLMInput, GoogleVertexAIBasePrediction, GoogleVertexAILLMResponse } from "../types/googlevertexai-types.js";
+export interface GoogleVertexAITextInput extends GoogleVertexAIBaseLLMInput {
+}
+interface GoogleVertexAILLMTextInstance {
+    content: string;
+}
+/**
+ * Models the data returned from the API call
+ */
+interface TextPrediction extends GoogleVertexAIBasePrediction {
+    content: string;
+}
+/**
+ * Enables calls to the Google Cloud's Vertex AI API to access
+ * Large Language Models.
+ *
+ * To use, you will need to have one of the following authentication
+ * methods in place:
+ * - You are logged into an account permitted to the Google Cloud project
+ *   using Vertex AI.
+ * - You are running this on a machine using a service account permitted to
+ *   the Google Cloud project using Vertex AI.
+ * - The `GOOGLE_APPLICATION_CREDENTIALS` environment variable is set to the
+ *   path of a credentials file for a service account permitted to the
+ *   Google Cloud project using Vertex AI.
+ */
+export declare class GoogleVertexAI extends BaseLLM implements GoogleVertexAITextInput {
+    model: string;
+    temperature: number;
+    maxOutputTokens: number;
+    topP: number;
+    topK: number;
+    private connection;
+    constructor(fields?: GoogleVertexAITextInput);
+    _llmType(): string;
+    _generate(prompts: string[], options: this["ParsedCallOptions"]): Promise<LLMResult>;
+    _generatePrompt(prompt: string, options: this["ParsedCallOptions"]): Promise<Generation[]>;
+    formatInstance(prompt: string): GoogleVertexAILLMTextInstance;
+    extractPredictionFromResponse(result: GoogleVertexAILLMResponse<TextPrediction>): TextPrediction;
+}
+export {};

package/dist/llms/googlevertexai.js

@@ -0,0 +1,93 @@
+import { BaseLLM } from "./base.js";
+import { GoogleVertexAIConnection } from "../util/googlevertexai-connection.js";
+/**
+ * Enables calls to the Google Cloud's Vertex AI API to access
+ * Large Language Models.
+ *
+ * To use, you will need to have one of the following authentication
+ * methods in place:
+ * - You are logged into an account permitted to the Google Cloud project
+ *   using Vertex AI.
+ * - You are running this on a machine using a service account permitted to
+ *   the Google Cloud project using Vertex AI.
+ * - The `GOOGLE_APPLICATION_CREDENTIALS` environment variable is set to the
+ *   path of a credentials file for a service account permitted to the
+ *   Google Cloud project using Vertex AI.
+ */
+export class GoogleVertexAI extends BaseLLM {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text-bison"
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.7
+        });
+        Object.defineProperty(this, "maxOutputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1024
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.8
+        });
+        Object.defineProperty(this, "topK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 40
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields?.model ?? this.model;
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxOutputTokens = fields?.maxOutputTokens ?? this.maxOutputTokens;
+        this.topP = fields?.topP ?? this.topP;
+        this.topK = fields?.topK ?? this.topK;
+        this.connection = new GoogleVertexAIConnection({ ...fields, ...this }, this.caller);
+    }
+    _llmType() {
+        return "googlevertexai";
+    }
+    async _generate(prompts, options) {
+        const generations = await Promise.all(prompts.map((prompt) => this._generatePrompt(prompt, options)));
+        return { generations };
+    }
+    async _generatePrompt(prompt, options) {
+        const instance = this.formatInstance(prompt);
+        const parameters = {
+            temperature: this.temperature,
+            topK: this.topK,
+            topP: this.topP,
+            maxOutputTokens: this.maxOutputTokens,
+        };
+        const result = await this.connection.request([instance], parameters, options);
+        const prediction = this.extractPredictionFromResponse(result);
+        return [
+            {
+                text: prediction.content,
+                generationInfo: prediction,
+            },
+        ];
+    }
+    formatInstance(prompt) {
+        return { content: prompt };
+    }
+    extractPredictionFromResponse(result) {
+        return result?.data?.predictions[0];
+    }
+}

package/dist/prompts/selectors/conditional.cjs

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isChatModel = exports.isLLM = exports.ConditionalPromptSelector = exports.BasePromptSelector = void 0;
 class BasePromptSelector {
+    async getPromptAsync(llm, options) {
+        const prompt = this.getPrompt(llm);
+        return prompt.partial(options?.partialVariables ?? {});
+    }
 }
 exports.BasePromptSelector = BasePromptSelector;
 class ConditionalPromptSelector extends BasePromptSelector {

package/dist/prompts/selectors/conditional.d.ts

@@ -2,8 +2,13 @@ import { BaseChatModel } from "../../chat_models/base.js";
 import { BasePromptTemplate } from "../base.js";
 import { BaseLanguageModel } from "../../base_language/index.js";
 import { BaseLLM } from "../../llms/base.js";
+import { PartialValues } from "../../schema/index.js";
+export type BaseGetPromptAsyncOptions = {
+    partialVariables?: PartialValues;
+};
 export declare abstract class BasePromptSelector {
     abstract getPrompt(llm: BaseLanguageModel): BasePromptTemplate;
+    getPromptAsync(llm: BaseLanguageModel, options?: BaseGetPromptAsyncOptions): Promise<BasePromptTemplate>;
 }
 export declare class ConditionalPromptSelector extends BasePromptSelector {
     defaultPrompt: BasePromptTemplate;

package/dist/prompts/selectors/conditional.js

@@ -1,4 +1,8 @@
 export class BasePromptSelector {
+    async getPromptAsync(llm, options) {
+        const prompt = this.getPrompt(llm);
+        return prompt.partial(options?.partialVariables ?? {});
+    }
 }
 export class ConditionalPromptSelector extends BasePromptSelector {
     constructor(default_prompt, conditionals = []) {

package/dist/retrievers/metal.d.ts

@@ -1,7 +1,8 @@
+import Metal from "@getmetal/metal-sdk";
 import { BaseRetriever } from "../schema/index.js";
 import { Document } from "../document.js";
 export interface MetalRetrieverFields {
-    client: import("@getmetal/metal-sdk").default;
+    client: Metal;
 }
 export declare class MetalRetriever extends BaseRetriever {
     private client;

package/dist/stores/message/redis.cjs

@@ -42,16 +42,7 @@ class RedisChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
         const orderedMessages = rawStoredMessages
             .reverse()
             .map((message) => JSON.parse(message));
-        const previousMessages = orderedMessages
-            .map((item) => ({
-            type: item.type,
-            data: {
-                role: item.role,
-                content: item.text,
-            },
-        }))
-            .filter((x) => x.type !== undefined && x.data.content !== undefined);
-        return (0, utils_js_1.mapStoredMessagesToChatMessages)(previousMessages);
+        return (0, utils_js_1.mapStoredMessagesToChatMessages)(orderedMessages);
     }
     async addMessage(message) {
         await this.ensureReadiness();

package/dist/stores/message/redis.js

@@ -39,16 +39,7 @@ export class RedisChatMessageHistory extends BaseListChatMessageHistory {
         const orderedMessages = rawStoredMessages
             .reverse()
             .map((message) => JSON.parse(message));
-        const previousMessages = orderedMessages
-            .map((item) => ({
-            type: item.type,
-            data: {
-                role: item.role,
-                content: item.text,
-            },
-        }))
-            .filter((x) => x.type !== undefined && x.data.content !== undefined);
-        return mapStoredMessagesToChatMessages(previousMessages);
+        return mapStoredMessagesToChatMessages(orderedMessages);
     }
     async addMessage(message) {
         await this.ensureReadiness();

package/dist/text_splitter.cjs

@@ -25,14 +25,17 @@ class TextSplitter {
     }
     async createDocuments(texts, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    metadatas = []) {
+    metadatas = [], chunkHeaderOptions = {}) {
+        // if no metadata is provided, we create an empty one for each text
         const _metadatas = metadatas.length > 0 ? metadatas : new Array(texts.length).fill({});
+        const { chunkHeader = "", chunkOverlapHeader = "(cont'd) ", appendChunkOverlapHeader = false, } = chunkHeaderOptions;
         const documents = new Array();
         for (let i = 0; i < texts.length; i += 1) {
             const text = texts[i];
             let lineCounterIndex = 1;
             let prevChunk = null;
             for (const chunk of await this.splitText(text)) {
+                let pageContent = chunkHeader;
                 // we need to count the \n that are in the text before getting removed by the splitting
                 let numberOfIntermediateNewLines = 0;
                 if (prevChunk) {
@@ -40,6 +43,9 @@ class TextSplitter {
                     const indexEndPrevChunk = text.indexOf(prevChunk) + prevChunk.length;
                     const removedNewlinesFromSplittingText = text.slice(indexEndPrevChunk, indexChunk);
                     numberOfIntermediateNewLines = (removedNewlinesFromSplittingText.match(/\n/g) || []).length;
+                    if (appendChunkOverlapHeader) {
+                        pageContent += chunkOverlapHeader;
+                    }
                 }
                 lineCounterIndex += numberOfIntermediateNewLines;
                 const newLinesCount = (chunk.match(/\n/g) || []).length;
@@ -54,8 +60,9 @@ class TextSplitter {
                     ..._metadatas[i],
                     loc,
                 };
+                pageContent += chunk;
                 documents.push(new document_js_1.Document({
-                    pageContent: chunk,
+                    pageContent,
                     metadata: metadataWithLinesNumber,
                 }));
                 lineCounterIndex += newLinesCount;
@@ -64,11 +71,11 @@ class TextSplitter {
         }
         return documents;
     }
-    async splitDocuments(documents) {
+    async splitDocuments(documents, chunkHeaderOptions = {}) {
         const selectedDocuments = documents.filter((doc) => doc.pageContent !== undefined);
         const texts = selectedDocuments.map((doc) => doc.pageContent);
         const metadatas = selectedDocuments.map((doc) => doc.metadata);
-        return this.createDocuments(texts, metadatas);
+        return this.createDocuments(texts, metadatas, chunkHeaderOptions);
     }
     joinDocs(docs, separator) {
         const text = docs.join(separator).trim();

package/dist/text_splitter.d.ts

@@ -4,13 +4,18 @@ export interface TextSplitterParams {
     chunkSize: number;
     chunkOverlap: number;
 }
+export type TextSplitterChunkHeaderOptions = {
+    chunkHeader?: string;
+    chunkOverlapHeader?: string;
+    appendChunkOverlapHeader?: boolean;
+};
 export declare abstract class TextSplitter implements TextSplitterParams {
     chunkSize: number;
     chunkOverlap: number;
     constructor(fields?: Partial<TextSplitterParams>);
     abstract splitText(text: string): Promise<string[]>;
-    createDocuments(texts: string[], metadatas?: Record<string, any>[]): Promise<Document[]>;
-    splitDocuments(documents: Document[]): Promise<Document[]>;
+    createDocuments(texts: string[], metadatas?: Record<string, any>[], chunkHeaderOptions?: TextSplitterChunkHeaderOptions): Promise<Document[]>;
+    splitDocuments(documents: Document[], chunkHeaderOptions?: TextSplitterChunkHeaderOptions): Promise<Document[]>;
     private joinDocs;
     mergeSplits(splits: string[], separator: string): string[];
 }

package/dist/text_splitter.js

@@ -22,14 +22,17 @@ export class TextSplitter {
     }
     async createDocuments(texts, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    metadatas = []) {
+    metadatas = [], chunkHeaderOptions = {}) {
+        // if no metadata is provided, we create an empty one for each text
         const _metadatas = metadatas.length > 0 ? metadatas : new Array(texts.length).fill({});
+        const { chunkHeader = "", chunkOverlapHeader = "(cont'd) ", appendChunkOverlapHeader = false, } = chunkHeaderOptions;
         const documents = new Array();
         for (let i = 0; i < texts.length; i += 1) {
             const text = texts[i];
             let lineCounterIndex = 1;
             let prevChunk = null;
             for (const chunk of await this.splitText(text)) {
+                let pageContent = chunkHeader;
                 // we need to count the \n that are in the text before getting removed by the splitting
                 let numberOfIntermediateNewLines = 0;
                 if (prevChunk) {
@@ -37,6 +40,9 @@ export class TextSplitter {
                     const indexEndPrevChunk = text.indexOf(prevChunk) + prevChunk.length;
                     const removedNewlinesFromSplittingText = text.slice(indexEndPrevChunk, indexChunk);
                     numberOfIntermediateNewLines = (removedNewlinesFromSplittingText.match(/\n/g) || []).length;
+                    if (appendChunkOverlapHeader) {
+                        pageContent += chunkOverlapHeader;
+                    }
                 }
                 lineCounterIndex += numberOfIntermediateNewLines;
                 const newLinesCount = (chunk.match(/\n/g) || []).length;
@@ -51,8 +57,9 @@ export class TextSplitter {
                     ..._metadatas[i],
                     loc,
                 };
+                pageContent += chunk;
                 documents.push(new Document({
-                    pageContent: chunk,
+                    pageContent,
                     metadata: metadataWithLinesNumber,
                 }));
                 lineCounterIndex += newLinesCount;
@@ -61,11 +68,11 @@ export class TextSplitter {
         }
         return documents;
     }
-    async splitDocuments(documents) {
+    async splitDocuments(documents, chunkHeaderOptions = {}) {
         const selectedDocuments = documents.filter((doc) => doc.pageContent !== undefined);
         const texts = selectedDocuments.map((doc) => doc.pageContent);
         const metadatas = selectedDocuments.map((doc) => doc.metadata);
-        return this.createDocuments(texts, metadatas);
+        return this.createDocuments(texts, metadatas, chunkHeaderOptions);
     }
     joinDocs(docs, separator) {
         const text = docs.join(separator).trim();

package/dist/types/googlevertexai-types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,47 @@
+import { BaseLLMParams } from "../llms/index.js";
+export interface GoogleVertexAIConnectionParams {
+    /** Hostname for the API call */
+    endpoint?: string;
+    /** Region where the LLM is stored */
+    location?: string;
+    /** Model to use */
+    model?: string;
+}
+export interface GoogleVertexAIModelParams {
+    /** Sampling temperature to use */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the completion.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Top-p changes how the model selects tokens for output.
+     *
+     * Tokens are selected from most probable to least until the sum
+     * of their probabilities equals the top-p value.
+     *
+     * For example, if tokens A, B, and C have a probability of
+     * .3, .2, and .1 and the top-p value is .5, then the model will
+     * select either A or B as the next token (using temperature).
+     */
+    topP?: number;
+    /**
+     * Top-k changes how the model selects tokens for output.
+     *
+     * A top-k of 1 means the selected token is the most probable among
+     * all tokens in the model’s vocabulary (also called greedy decoding),
+     * while a top-k of 3 means that the next token is selected from
+     * among the 3 most probable tokens (using temperature).
+     */
+    topK?: number;
+}
+export interface GoogleVertexAIBaseLLMInput extends BaseLLMParams, GoogleVertexAIConnectionParams, GoogleVertexAIModelParams {
+}
+export interface GoogleVertexAIBasePrediction {
+    safetyAttributes?: any;
+}
+export interface GoogleVertexAILLMResponse<PredictionType extends GoogleVertexAIBasePrediction> {
+    data: {
+        predictions: PredictionType[];
+    };
+}

package/dist/types/googlevertexai-types.js

@@ -0,0 +1 @@
+export {};

package/dist/util/googlevertexai-connection.cjs

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleVertexAIConnection = void 0;
+const google_auth_library_1 = require("google-auth-library");
+class GoogleVertexAIConnection {
+    constructor(fields, caller) {
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "us-central1-aiplatform.googleapis.com"
+        });
+        Object.defineProperty(this, "location", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "us-central1"
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "auth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.caller = caller;
+        this.endpoint = fields?.endpoint ?? this.endpoint;
+        this.location = fields?.location ?? this.location;
+        this.model = fields?.model ?? this.model;
+        this.auth = new google_auth_library_1.GoogleAuth({
+            scopes: "https://www.googleapis.com/auth/cloud-platform",
+        });
+    }
+    async request(instances, parameters, options) {
+        const client = await this.auth.getClient();
+        const projectId = await this.auth.getProjectId();
+        const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
+        const method = "POST";
+        const data = {
+            instances,
+            parameters,
+        };
+        const opts = {
+            url,
+            method,
+            data,
+        };
+        async function _request() {
+            return client.request(opts);
+        }
+        const response = await this.caller.callWithOptions({ signal: options.signal }, _request.bind(client));
+        return response;
+    }
+}
+exports.GoogleVertexAIConnection = GoogleVertexAIConnection;

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

@@ -0,0 +1,13 @@
+import { GoogleAuth } from "google-auth-library";
+import { BaseLanguageModelCallOptions } from "../base_language/index.js";
+import { AsyncCaller } from "./async_caller.js";
+import { GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMResponse, GoogleVertexAIModelParams } from "../types/googlevertexai-types.js";
+export declare class GoogleVertexAIConnection<CallOptions extends BaseLanguageModelCallOptions, InstanceType, PredictionType extends GoogleVertexAIBasePrediction> implements GoogleVertexAIConnectionParams {
+    caller: AsyncCaller;
+    endpoint: string;
+    location: string;
+    model: string;
+    auth: GoogleAuth;
+    constructor(fields: GoogleVertexAIConnectionParams | undefined, caller: AsyncCaller);
+    request(instances: [InstanceType], parameters: GoogleVertexAIModelParams, options: CallOptions): Promise<GoogleVertexAILLMResponse<PredictionType>>;
+}

package/dist/util/googlevertexai-connection.js

@@ -0,0 +1,62 @@
+import { GoogleAuth } from "google-auth-library";
+export class GoogleVertexAIConnection {
+    constructor(fields, caller) {
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "us-central1-aiplatform.googleapis.com"
+        });
+        Object.defineProperty(this, "location", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "us-central1"
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "auth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.caller = caller;
+        this.endpoint = fields?.endpoint ?? this.endpoint;
+        this.location = fields?.location ?? this.location;
+        this.model = fields?.model ?? this.model;
+        this.auth = new GoogleAuth({
+            scopes: "https://www.googleapis.com/auth/cloud-platform",
+        });
+    }
+    async request(instances, parameters, options) {
+        const client = await this.auth.getClient();
+        const projectId = await this.auth.getProjectId();
+        const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
+        const method = "POST";
+        const data = {
+            instances,
+            parameters,
+        };
+        const opts = {
+            url,
+            method,
+            data,
+        };
+        async function _request() {
+            return client.request(opts);
+        }
+        const response = await this.caller.callWithOptions({ signal: options.signal }, _request.bind(client));
+        return response;
+    }
+}