langchain 0.0.154 → 0.0.156

package/dist/util/fast-json-patch/src/helpers.js

@@ -0,0 +1,181 @@
+// @ts-nocheck
+// Inlined because of ESM import issues
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2022 Joachim Wester
+ * MIT licensed
+ */
+const _hasOwnProperty = Object.prototype.hasOwnProperty;
+export function hasOwnProperty(obj, key) {
+    return _hasOwnProperty.call(obj, key);
+}
+export function _objectKeys(obj) {
+    if (Array.isArray(obj)) {
+        const keys = new Array(obj.length);
+        for (let k = 0; k < keys.length; k++) {
+            keys[k] = "" + k;
+        }
+        return keys;
+    }
+    if (Object.keys) {
+        return Object.keys(obj);
+    }
+    let keys = [];
+    for (let i in obj) {
+        if (hasOwnProperty(obj, i)) {
+            keys.push(i);
+        }
+    }
+    return keys;
+}
+/**
+ * Deeply clone the object.
+ * https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+ * @param  {any} obj value to clone
+ * @return {any} cloned obj
+ */
+export function _deepClone(obj) {
+    switch (typeof obj) {
+        case "object":
+            return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5
+        case "undefined":
+            return null; //this is how JSON.stringify behaves for array items
+        default:
+            return obj; //no need to clone primitives
+    }
+}
+//3x faster than cached /^\d+$/.test(str)
+export function isInteger(str) {
+    let i = 0;
+    const len = str.length;
+    let charCode;
+    while (i < len) {
+        charCode = str.charCodeAt(i);
+        if (charCode >= 48 && charCode <= 57) {
+            i++;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+/**
+ * Escapes a json pointer path
+ * @param path The raw pointer
+ * @return the Escaped path
+ */
+export function escapePathComponent(path) {
+    if (path.indexOf("/") === -1 && path.indexOf("~") === -1)
+        return path;
+    return path.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+/**
+ * Unescapes a json pointer path
+ * @param path The escaped pointer
+ * @return The unescaped path
+ */
+export function unescapePathComponent(path) {
+    return path.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+export function _getPathRecursive(root, obj) {
+    let found;
+    for (let key in root) {
+        if (hasOwnProperty(root, key)) {
+            if (root[key] === obj) {
+                return escapePathComponent(key) + "/";
+            }
+            else if (typeof root[key] === "object") {
+                found = _getPathRecursive(root[key], obj);
+                if (found != "") {
+                    return escapePathComponent(key) + "/" + found;
+                }
+            }
+        }
+    }
+    return "";
+}
+export function getPath(root, obj) {
+    if (root === obj) {
+        return "/";
+    }
+    const path = _getPathRecursive(root, obj);
+    if (path === "") {
+        throw new Error("Object not found in root");
+    }
+    return `/${path}`;
+}
+/**
+ * Recursively checks whether an object has any undefined values inside.
+ */
+export function hasUndefined(obj) {
+    if (obj === undefined) {
+        return true;
+    }
+    if (obj) {
+        if (Array.isArray(obj)) {
+            for (let i = 0, len = obj.length; i < len; i++) {
+                if (hasUndefined(obj[i])) {
+                    return true;
+                }
+            }
+        }
+        else if (typeof obj === "object") {
+            const objKeys = _objectKeys(obj);
+            const objKeysLength = objKeys.length;
+            for (var i = 0; i < objKeysLength; i++) {
+                if (hasUndefined(obj[objKeys[i]])) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function patchErrorMessageFormatter(message, args) {
+    const messageParts = [message];
+    for (const key in args) {
+        const value = typeof args[key] === "object"
+            ? JSON.stringify(args[key], null, 2)
+            : args[key]; // pretty print
+        if (typeof value !== "undefined") {
+            messageParts.push(`${key}: ${value}`);
+        }
+    }
+    return messageParts.join("\n");
+}
+export class PatchError extends Error {
+    constructor(message, name, index, operation, tree) {
+        super(patchErrorMessageFormatter(message, { name, index, operation, tree }));
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: name
+        });
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: index
+        });
+        Object.defineProperty(this, "operation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: operation
+        });
+        Object.defineProperty(this, "tree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tree
+        });
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain, see https://stackoverflow.com/a/48342359
+        this.message = patchErrorMessageFormatter(message, {
+            name,
+            index,
+            operation,
+            tree,
+        });
+    }
+}

package/dist/util/googlevertexai-webauth.cjs

@@ -11,19 +11,23 @@ class WebGoogleAuth {
             writable: true,
             value: void 0
         });
+        const accessToken = options?.accessToken;
         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 };
+        this.options = { ...options, accessToken, 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);
+        let { accessToken } = this.options;
+        if (accessToken === undefined) {
+            accessToken = await (0, google_1.getAccessToken)(this.options);
+        }
         if (opts.url == null)
             throw new Error("Missing URL");
         const fetchOptions = {

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

@@ -3,6 +3,7 @@ import type { GoogleVertexAIAbstractedClient } from "../types/googlevertexai-typ
 export type WebGoogleAuthOptions = {
     credentials: string | Credentials;
     scope?: string | string[];
+    accessToken?: string;
 };
 export declare class WebGoogleAuth implements GoogleVertexAIAbstractedClient {
     options: WebGoogleAuthOptions;

package/dist/util/googlevertexai-webauth.js

@@ -8,19 +8,23 @@ export class WebGoogleAuth {
             writable: true,
             value: void 0
         });
+        const accessToken = options?.accessToken;
         const credentials = options?.credentials ??
             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 };
+        this.options = { ...options, accessToken, credentials, scope };
     }
     async getProjectId() {
         const credentials = getCredentials(this.options.credentials);
         return credentials.project_id;
     }
     async request(opts) {
-        const accessToken = await getAccessToken(this.options);
+        let { accessToken } = this.options;
+        if (accessToken === undefined) {
+            accessToken = await getAccessToken(this.options);
+        }
         if (opts.url == null)
             throw new Error("Missing URL");
         const fetchOptions = {

package/dist/util/stream.cjs

@@ -1,47 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableReadableStream = exports.readableStreamToAsyncIterable = void 0;
+exports.IterableReadableStream = void 0;
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
  */
-function readableStreamToAsyncIterable(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-stream, preventCancel = false) {
-    if (stream[Symbol.asyncIterator]) {
-        return stream[Symbol.asyncIterator]();
-    }
-    const reader = stream.getReader();
-    return {
-        async next() {
-            try {
-                const result = await reader.read();
-                if (result.done)
-                    reader.releaseLock(); // release lock when stream becomes closed
-                return result;
-            }
-            catch (e) {
-                reader.releaseLock(); // release lock when stream becomes errored
-                throw e;
-            }
-        },
-        async return() {
-            if (!preventCancel) {
-                const cancelPromise = reader.cancel(); // cancel first, but don't await yet
-                reader.releaseLock(); // release lock first
-                await cancelPromise; // now await it
-            }
-            else {
-                reader.releaseLock();
-            }
-            return { done: true, value: undefined };
-        },
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-    };
-}
-exports.readableStreamToAsyncIterable = readableStreamToAsyncIterable;
 class IterableReadableStream extends ReadableStream {
     constructor() {
         super(...arguments);
@@ -75,7 +38,7 @@ class IterableReadableStream extends ReadableStream {
         const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
         this.reader.releaseLock(); // release lock first
         await cancelPromise; // now await it
-        return { done: true, value: undefined };
+        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore chunk value anyway
     }
     [Symbol.asyncIterator]() {
         return this;
@@ -86,7 +49,6 @@ class IterableReadableStream extends ReadableStream {
         return new IterableReadableStream({
             start(controller) {
                 return pump();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 function pump() {
                     return reader.read().then(({ done, value }) => {
                         // When no more data needs to be consumed, close the stream

package/dist/util/stream.d.ts

@@ -1,11 +1,10 @@
-export declare function readableStreamToAsyncIterable(stream: any, preventCancel?: boolean): any;
 export declare class IterableReadableStream<T> extends ReadableStream<T> {
     reader: ReadableStreamDefaultReader<T>;
     ensureReader(): void;
     next(): Promise<ReadableStreamReadResult<T>>;
     return(): Promise<{
         done: boolean;
-        value: undefined;
+        value: T;
     }>;
     [Symbol.asyncIterator](): this;
     static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;

package/dist/util/stream.js

@@ -2,42 +2,6 @@
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
  */
-export function readableStreamToAsyncIterable(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-stream, preventCancel = false) {
-    if (stream[Symbol.asyncIterator]) {
-        return stream[Symbol.asyncIterator]();
-    }
-    const reader = stream.getReader();
-    return {
-        async next() {
-            try {
-                const result = await reader.read();
-                if (result.done)
-                    reader.releaseLock(); // release lock when stream becomes closed
-                return result;
-            }
-            catch (e) {
-                reader.releaseLock(); // release lock when stream becomes errored
-                throw e;
-            }
-        },
-        async return() {
-            if (!preventCancel) {
-                const cancelPromise = reader.cancel(); // cancel first, but don't await yet
-                reader.releaseLock(); // release lock first
-                await cancelPromise; // now await it
-            }
-            else {
-                reader.releaseLock();
-            }
-            return { done: true, value: undefined };
-        },
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-    };
-}
 export class IterableReadableStream extends ReadableStream {
     constructor() {
         super(...arguments);
@@ -71,7 +35,7 @@ export class IterableReadableStream extends ReadableStream {
         const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
         this.reader.releaseLock(); // release lock first
         await cancelPromise; // now await it
-        return { done: true, value: undefined };
+        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore chunk value anyway
     }
     [Symbol.asyncIterator]() {
         return this;
@@ -82,7 +46,6 @@ export class IterableReadableStream extends ReadableStream {
         return new IterableReadableStream({
             start(controller) {
                 return pump();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 function pump() {
                     return reader.read().then(({ done, value }) => {
                         // When no more data needs to be consumed, close the stream

package/dist/vectorstores/cloudflare_vectorize.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudflareVectorizeStore = void 0;
+const uuid = __importStar(require("uuid"));
+const base_js_1 = require("./base.cjs");
+const document_js_1 = require("../document.cjs");
+const chunk_js_1 = require("../util/chunk.cjs");
+const async_caller_js_1 = require("../util/async_caller.cjs");
+/**
+ * Class that extends the VectorStore class and provides methods to
+ * interact with the Cloudflare Vectorize vector database.
+ */
+class CloudflareVectorizeStore extends base_js_1.VectorStore {
+    _vectorstoreType() {
+        return "cloudflare_vectorize";
+    }
+    constructor(embeddings, args) {
+        super(embeddings, args);
+        Object.defineProperty(this, "textKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.embeddings = embeddings;
+        const { index, textKey, ...asyncCallerArgs } = args;
+        if (!index) {
+            throw new Error("Must supply a Vectorize index binding, eg { index: env.VECTORIZE }");
+        }
+        this.index = index;
+        this.textKey = textKey ?? "text";
+        this.caller = new async_caller_js_1.AsyncCaller({
+            maxConcurrency: 6,
+            maxRetries: 0,
+            ...asyncCallerArgs,
+        });
+    }
+    /**
+     * Method that adds documents to the Vectorize database.
+     * @param documents Array of documents to add.
+     * @param options Optional ids for the documents.
+     * @returns Promise that resolves with the ids of the added documents.
+     */
+    async addDocuments(documents, options) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
+    }
+    /**
+     * Method that adds vectors to the Vectorize database.
+     * @param vectors Array of vectors to add.
+     * @param documents Array of documents associated with the vectors.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with the ids of the added vectors.
+     */
+    async addVectors(vectors, documents, options) {
+        const ids = Array.isArray(options) ? options : options?.ids;
+        const documentIds = ids == null ? documents.map(() => uuid.v4()) : ids;
+        const vectorizeVectors = vectors.map((values, idx) => {
+            const metadata = {
+                ...documents[idx].metadata,
+                [this.textKey]: documents[idx].pageContent,
+            };
+            return {
+                id: documentIds[idx],
+                metadata,
+                values,
+            };
+        });
+        // Stick to a limit of 500 vectors per upsert request
+        const chunkSize = 500;
+        const chunkedVectors = (0, chunk_js_1.chunkArray)(vectorizeVectors, chunkSize);
+        const batchRequests = chunkedVectors.map((chunk) => this.caller.call(async () => this.index.upsert(chunk)));
+        await Promise.all(batchRequests);
+        return documentIds;
+    }
+    /**
+     * Method that deletes vectors from the Vectorize database.
+     * @param params Parameters for the delete operation.
+     * @returns Promise that resolves when the delete operation is complete.
+     */
+    async delete(params) {
+        const batchSize = 1000;
+        const batchedIds = (0, chunk_js_1.chunkArray)(params.ids, batchSize);
+        const batchRequests = batchedIds.map((batchIds) => this.caller.call(async () => this.index.deleteByIds(batchIds)));
+        await Promise.all(batchRequests);
+    }
+    /**
+     * Method that performs a similarity search in the Vectorize database and
+     * returns the results along with their scores.
+     * @param query Query vector for the similarity search.
+     * @param k Number of top results to return.
+     * @returns Promise that resolves with an array of documents and their scores.
+     */
+    async similaritySearchVectorWithScore(query, k) {
+        const results = await this.index.query(query, {
+            returnVectors: true,
+            topK: k,
+        });
+        const result = [];
+        if (results.matches) {
+            for (const res of results.matches) {
+                const { [this.textKey]: pageContent, ...metadata } = res.vector?.metadata ?? {};
+                result.push([
+                    new document_js_1.Document({ metadata, pageContent: pageContent }),
+                    res.score,
+                ]);
+            }
+        }
+        return result;
+    }
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from texts.
+     * @param texts Array of texts to add to the Vectorize database.
+     * @param metadatas Metadata associated with the texts.
+     * @param embeddings Embeddings to use for the texts.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
+        const docs = [];
+        for (let i = 0; i < texts.length; i += 1) {
+            const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
+            const newDoc = new document_js_1.Document({
+                pageContent: texts[i],
+                metadata,
+            });
+            docs.push(newDoc);
+        }
+        return CloudflareVectorizeStore.fromDocuments(docs, embeddings, dbConfig);
+    }
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from documents.
+     * @param docs Array of documents to add to the Vectorize database.
+     * @param embeddings Embeddings to use for the documents.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static async fromDocuments(docs, embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from an existing index.
+     * @param embeddings Embeddings to use for the documents.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static async fromExistingIndex(embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        return instance;
+    }
+}
+exports.CloudflareVectorizeStore = CloudflareVectorizeStore;

package/dist/vectorstores/cloudflare_vectorize.d.ts

@@ -0,0 +1,90 @@
+import { VectorizeIndex, VectorizeVectorMetadata } from "@cloudflare/workers-types";
+import { VectorStore } from "./base.js";
+import { Embeddings } from "../embeddings/base.js";
+import { Document } from "../document.js";
+import { AsyncCaller, type AsyncCallerParams } from "../util/async_caller.js";
+export interface VectorizeLibArgs extends AsyncCallerParams {
+    index: VectorizeIndex;
+    textKey?: string;
+}
+/**
+ * Type that defines the parameters for the delete operation in the
+ * CloudflareVectorizeStore class. It includes ids, deleteAll flag, and namespace.
+ */
+export type VectorizeDeleteParams = {
+    ids: string[];
+};
+/**
+ * Class that extends the VectorStore class and provides methods to
+ * interact with the Cloudflare Vectorize vector database.
+ */
+export declare class CloudflareVectorizeStore extends VectorStore {
+    textKey: string;
+    namespace?: string;
+    index: VectorizeIndex;
+    caller: AsyncCaller;
+    _vectorstoreType(): string;
+    constructor(embeddings: Embeddings, args: VectorizeLibArgs);
+    /**
+     * Method that adds documents to the Vectorize database.
+     * @param documents Array of documents to add.
+     * @param options Optional ids for the documents.
+     * @returns Promise that resolves with the ids of the added documents.
+     */
+    addDocuments(documents: Document[], options?: {
+        ids?: string[];
+    } | string[]): Promise<string[]>;
+    /**
+     * Method that adds vectors to the Vectorize database.
+     * @param vectors Array of vectors to add.
+     * @param documents Array of documents associated with the vectors.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with the ids of the added vectors.
+     */
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    } | string[]): Promise<string[]>;
+    /**
+     * Method that deletes vectors from the Vectorize database.
+     * @param params Parameters for the delete operation.
+     * @returns Promise that resolves when the delete operation is complete.
+     */
+    delete(params: VectorizeDeleteParams): Promise<void>;
+    /**
+     * Method that performs a similarity search in the Vectorize database and
+     * returns the results along with their scores.
+     * @param query Query vector for the similarity search.
+     * @param k Number of top results to return.
+     * @returns Promise that resolves with an array of documents and their scores.
+     */
+    similaritySearchVectorWithScore(query: number[], k: number): Promise<[Document, number][]>;
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from texts.
+     * @param texts Array of texts to add to the Vectorize database.
+     * @param metadatas Metadata associated with the texts.
+     * @param embeddings Embeddings to use for the texts.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static fromTexts(texts: string[], metadatas: Record<string, VectorizeVectorMetadata>[] | Record<string, VectorizeVectorMetadata>, embeddings: Embeddings, dbConfig: VectorizeLibArgs): Promise<CloudflareVectorizeStore>;
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from documents.
+     * @param docs Array of documents to add to the Vectorize database.
+     * @param embeddings Embeddings to use for the documents.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @param options Optional ids for the vectors.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: VectorizeLibArgs): Promise<CloudflareVectorizeStore>;
+    /**
+     * Static method that creates a new instance of the CloudflareVectorizeStore class
+     * from an existing index.
+     * @param embeddings Embeddings to use for the documents.
+     * @param dbConfig Configuration for the Vectorize database.
+     * @returns Promise that resolves with a new instance of the CloudflareVectorizeStore class.
+     */
+    static fromExistingIndex(embeddings: Embeddings, dbConfig: VectorizeLibArgs): Promise<CloudflareVectorizeStore>;
+}