langchain 0.0.159 → 0.0.161

package/dist/schema/runnable/base.cjs

@@ -858,6 +858,9 @@ class RunnableMap extends Runnable {
             this.steps[key] = _coerceToRunnable(value);
         }
     }
+    static from(steps) {
+        return new RunnableMap({ steps });
+    }
     async invoke(input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {

package/dist/schema/runnable/base.d.ts

@@ -287,6 +287,7 @@ export declare class RunnableMap<RunInput> extends Runnable<RunInput, Record<str
     constructor(fields: {
         steps: Record<string, RunnableLike<RunInput>>;
     });
+    static from<RunInput>(steps: Record<string, RunnableLike<RunInput>>): RunnableMap<RunInput>;
     invoke(input: RunInput, options?: Partial<BaseCallbackConfig>): Promise<Record<string, any>>;
 }
 /**

package/dist/schema/runnable/base.js

@@ -847,6 +847,9 @@ export class RunnableMap extends Runnable {
             this.steps[key] = _coerceToRunnable(value);
         }
     }
+    static from(steps) {
+        return new RunnableMap({ steps });
+    }
     async invoke(input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {

package/dist/text_splitter.cjs

@@ -76,21 +76,30 @@ class TextSplitter extends document_js_2.BaseDocumentTransformer {
             const text = texts[i];
             let lineCounterIndex = 1;
             let prevChunk = null;
+            let indexPrevChunk = -1;
             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) {
-                    const indexChunk = text.indexOf(chunk);
-                    const indexEndPrevChunk = text.indexOf(prevChunk) + (await this.lengthFunction(prevChunk));
-                    const removedNewlinesFromSplittingText = text.slice(indexEndPrevChunk, indexChunk);
-                    numberOfIntermediateNewLines = (removedNewlinesFromSplittingText.match(/\n/g) || []).length;
+                const indexChunk = text.indexOf(chunk, indexPrevChunk + 1);
+                if (prevChunk === null) {
+                    const newLinesBeforeFirstChunk = this.numberOfNewLines(text, 0, indexChunk);
+                    lineCounterIndex += newLinesBeforeFirstChunk;
+                }
+                else {
+                    const indexEndPrevChunk = indexPrevChunk + (await this.lengthFunction(prevChunk));
+                    if (indexEndPrevChunk < indexChunk) {
+                        const numberOfIntermediateNewLines = this.numberOfNewLines(text, indexEndPrevChunk, indexChunk);
+                        lineCounterIndex += numberOfIntermediateNewLines;
+                    }
+                    else if (indexEndPrevChunk > indexChunk) {
+                        const numberOfIntermediateNewLines = this.numberOfNewLines(text, indexChunk, indexEndPrevChunk);
+                        lineCounterIndex -= numberOfIntermediateNewLines;
+                    }
                     if (appendChunkOverlapHeader) {
                         pageContent += chunkOverlapHeader;
                     }
                 }
-                lineCounterIndex += numberOfIntermediateNewLines;
-                const newLinesCount = (chunk.match(/\n/g) || []).length;
+                const newLinesCount = this.numberOfNewLines(chunk);
                 const loc = _metadatas[i].loc && typeof _metadatas[i].loc === "object"
                     ? { ..._metadatas[i].loc }
                     : {};
@@ -109,10 +118,15 @@ class TextSplitter extends document_js_2.BaseDocumentTransformer {
                 }));
                 lineCounterIndex += newLinesCount;
                 prevChunk = chunk;
+                indexPrevChunk = indexChunk;
             }
         }
         return documents;
     }
+    numberOfNewLines(text, start, end) {
+        const textSection = text.slice(start, end);
+        return (textSection.match(/\n/g) || []).length;
+    }
     async splitDocuments(documents, chunkHeaderOptions = {}) {
         const selectedDocuments = documents.filter((doc) => doc.pageContent !== undefined);
         const texts = selectedDocuments.map((doc) => doc.pageContent);

package/dist/text_splitter.d.ts

@@ -23,6 +23,7 @@ export declare abstract class TextSplitter extends BaseDocumentTransformer imple
     abstract splitText(text: string): Promise<string[]>;
     protected splitOnSeparator(text: string, separator: string): string[];
     createDocuments(texts: string[], metadatas?: Record<string, any>[], chunkHeaderOptions?: TextSplitterChunkHeaderOptions): Promise<Document[]>;
+    private numberOfNewLines;
     splitDocuments(documents: Document[], chunkHeaderOptions?: TextSplitterChunkHeaderOptions): Promise<Document[]>;
     private joinDocs;
     mergeSplits(splits: string[], separator: string): Promise<string[]>;

package/dist/text_splitter.js

@@ -73,21 +73,30 @@ export class TextSplitter extends BaseDocumentTransformer {
             const text = texts[i];
             let lineCounterIndex = 1;
             let prevChunk = null;
+            let indexPrevChunk = -1;
             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) {
-                    const indexChunk = text.indexOf(chunk);
-                    const indexEndPrevChunk = text.indexOf(prevChunk) + (await this.lengthFunction(prevChunk));
-                    const removedNewlinesFromSplittingText = text.slice(indexEndPrevChunk, indexChunk);
-                    numberOfIntermediateNewLines = (removedNewlinesFromSplittingText.match(/\n/g) || []).length;
+                const indexChunk = text.indexOf(chunk, indexPrevChunk + 1);
+                if (prevChunk === null) {
+                    const newLinesBeforeFirstChunk = this.numberOfNewLines(text, 0, indexChunk);
+                    lineCounterIndex += newLinesBeforeFirstChunk;
+                }
+                else {
+                    const indexEndPrevChunk = indexPrevChunk + (await this.lengthFunction(prevChunk));
+                    if (indexEndPrevChunk < indexChunk) {
+                        const numberOfIntermediateNewLines = this.numberOfNewLines(text, indexEndPrevChunk, indexChunk);
+                        lineCounterIndex += numberOfIntermediateNewLines;
+                    }
+                    else if (indexEndPrevChunk > indexChunk) {
+                        const numberOfIntermediateNewLines = this.numberOfNewLines(text, indexChunk, indexEndPrevChunk);
+                        lineCounterIndex -= numberOfIntermediateNewLines;
+                    }
                     if (appendChunkOverlapHeader) {
                         pageContent += chunkOverlapHeader;
                     }
                 }
-                lineCounterIndex += numberOfIntermediateNewLines;
-                const newLinesCount = (chunk.match(/\n/g) || []).length;
+                const newLinesCount = this.numberOfNewLines(chunk);
                 const loc = _metadatas[i].loc && typeof _metadatas[i].loc === "object"
                     ? { ..._metadatas[i].loc }
                     : {};
@@ -106,10 +115,15 @@ export class TextSplitter extends BaseDocumentTransformer {
                 }));
                 lineCounterIndex += newLinesCount;
                 prevChunk = chunk;
+                indexPrevChunk = indexChunk;
             }
         }
         return documents;
     }
+    numberOfNewLines(text, start, end) {
+        const textSection = text.slice(start, end);
+        return (textSection.match(/\n/g) || []).length;
+    }
     async splitDocuments(documents, chunkHeaderOptions = {}) {
         const selectedDocuments = documents.filter((doc) => doc.pageContent !== undefined);
         const texts = selectedDocuments.map((doc) => doc.pageContent);

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

@@ -1,8 +1,10 @@
 import { BaseLLMParams } from "../llms/base.js";
-export interface GoogleVertexAIConnectionParams<AuthOptions> {
+export interface GoogleConnectionParams<AuthOptions> {
+    authOptions?: AuthOptions;
+}
+export interface GoogleVertexAIConnectionParams<AuthOptions> extends GoogleConnectionParams<AuthOptions> {
     /** Hostname for the API call */
     endpoint?: string;
-    authOptions?: AuthOptions;
     /** Region where the LLM is stored */
     location?: string;
     /** The version of the API functions. Part of the path. */
@@ -40,10 +42,10 @@ export interface GoogleVertexAIModelParams {
 }
 export interface GoogleVertexAIBaseLLMInput<AuthOptions> extends BaseLLMParams, GoogleVertexAIConnectionParams<AuthOptions>, GoogleVertexAIModelParams {
 }
-export interface GoogleVertexAIResponse {
+export interface GoogleResponse {
     data: any;
 }
-export interface GoogleVertexAIBasePrediction extends GoogleVertexAIResponse {
+export interface GoogleVertexAIBasePrediction extends GoogleResponse {
     safetyAttributes?: any;
 }
 export interface GoogleVertexAILLMResponse<PredictionType extends GoogleVertexAIBasePrediction> {
@@ -51,7 +53,7 @@ export interface GoogleVertexAILLMResponse<PredictionType extends GoogleVertexAI
         predictions: PredictionType[];
     };
 }
-export interface GoogleVertexAIAbstractedClient {
+export interface GoogleAbstractedClient {
     request: (opts: {
         url?: string;
         method?: "GET" | "POST";

package/dist/util/googlevertexai-connection.cjs

@@ -1,32 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoogleVertexAILLMConnection = exports.GoogleVertexAIConnection = void 0;
-class GoogleVertexAIConnection {
-    constructor(fields, caller, client) {
+exports.GoogleVertexAILLMConnection = exports.GoogleVertexAIConnection = exports.GoogleConnection = void 0;
+class GoogleConnection {
+    constructor(caller, client) {
         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, "apiVersion", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "v1"
-        });
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -34,14 +16,8 @@ class GoogleVertexAIConnection {
             value: void 0
         });
         this.caller = caller;
-        this.endpoint = fields?.endpoint ?? this.endpoint;
-        this.location = fields?.location ?? this.location;
-        this.apiVersion = fields?.apiVersion ?? this.apiVersion;
         this.client = client;
     }
-    buildMethod() {
-        return "POST";
-    }
     async _request(data, options) {
         const url = await this.buildUrl();
         const method = this.buildMethod();
@@ -64,6 +40,38 @@ class GoogleVertexAIConnection {
         }
     }
 }
+exports.GoogleConnection = GoogleConnection;
+class GoogleVertexAIConnection extends GoogleConnection {
+    constructor(fields, caller, client) {
+        super(caller, client);
+        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, "apiVersion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "v1"
+        });
+        this.caller = caller;
+        this.endpoint = fields?.endpoint ?? this.endpoint;
+        this.location = fields?.location ?? this.location;
+        this.apiVersion = fields?.apiVersion ?? this.apiVersion;
+        this.client = client;
+    }
+    buildMethod() {
+        return "POST";
+    }
+}
 exports.GoogleVertexAIConnection = GoogleVertexAIConnection;
 class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
     constructor(fields, caller, client) {

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

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

package/dist/util/googlevertexai-connection.js

@@ -1,29 +1,11 @@
-export class GoogleVertexAIConnection {
-    constructor(fields, caller, client) {
+export class GoogleConnection {
+    constructor(caller, client) {
         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, "apiVersion", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "v1"
-        });
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -31,14 +13,8 @@ export class GoogleVertexAIConnection {
             value: void 0
         });
         this.caller = caller;
-        this.endpoint = fields?.endpoint ?? this.endpoint;
-        this.location = fields?.location ?? this.location;
-        this.apiVersion = fields?.apiVersion ?? this.apiVersion;
         this.client = client;
     }
-    buildMethod() {
-        return "POST";
-    }
     async _request(data, options) {
         const url = await this.buildUrl();
         const method = this.buildMethod();
@@ -61,6 +37,37 @@ export class GoogleVertexAIConnection {
         }
     }
 }
+export class GoogleVertexAIConnection extends GoogleConnection {
+    constructor(fields, caller, client) {
+        super(caller, client);
+        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, "apiVersion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "v1"
+        });
+        this.caller = caller;
+        this.endpoint = fields?.endpoint ?? this.endpoint;
+        this.location = fields?.location ?? this.location;
+        this.apiVersion = fields?.apiVersion ?? this.apiVersion;
+        this.client = client;
+    }
+    buildMethod() {
+        return "POST";
+    }
+}
 export class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
     constructor(fields, caller, client) {
         super(fields, caller, client);

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

@@ -1,11 +1,11 @@
 import { Credentials } from "web-auth-library/google";
-import type { GoogleVertexAIAbstractedClient } from "../types/googlevertexai-types.js";
+import type { GoogleAbstractedClient } from "../types/googlevertexai-types.js";
 export type WebGoogleAuthOptions = {
     credentials: string | Credentials;
     scope?: string | string[];
     accessToken?: string;
 };
-export declare class WebGoogleAuth implements GoogleVertexAIAbstractedClient {
+export declare class WebGoogleAuth implements GoogleAbstractedClient {
     options: WebGoogleAuthOptions;
     constructor(options?: WebGoogleAuthOptions);
     getProjectId(): Promise<string>;

package/dist/vectorstores/googlevertexai.d.ts

@@ -4,7 +4,7 @@ import { Embeddings } from "../embeddings/base.js";
 import { Document, DocumentInput } from "../document.js";
 import { GoogleVertexAIConnection } from "../util/googlevertexai-connection.js";
 import { AsyncCaller, AsyncCallerCallOptions, AsyncCallerParams } from "../util/async_caller.js";
-import { GoogleVertexAIConnectionParams, GoogleVertexAIResponse } from "../types/googlevertexai-types.js";
+import { GoogleVertexAIConnectionParams, GoogleResponse } from "../types/googlevertexai-types.js";
 import { Docstore } from "../schema/index.js";
 /**
  * Allows us to create IdDocument classes that contain the ID.
@@ -26,7 +26,7 @@ interface DeployedIndex {
     id: string;
     index: string;
 }
-interface IndexEndpointResponse extends GoogleVertexAIResponse {
+interface IndexEndpointResponse extends GoogleResponse {
     data: {
         deployedIndexes: DeployedIndex[];
         publicEndpointDomainName: string;
@@ -49,7 +49,7 @@ export interface MatchingEngineDeleteParams {
 interface RemoveDatapointParams extends GoogleVertexAIConnectionParams<GoogleAuthOptions> {
     index: string;
 }
-interface RemoveDatapointResponse extends GoogleVertexAIResponse {
+interface RemoveDatapointResponse extends GoogleResponse {
 }
 declare class RemoveDatapointConnection extends GoogleVertexAIConnection<AsyncCallerCallOptions, RemoveDatapointResponse, GoogleAuthOptions> {
     index: string;
@@ -75,7 +75,7 @@ interface IndexDatapoint {
     restricts?: Restriction[];
     crowdingTag?: CrowdingTag;
 }
-interface UpsertDatapointResponse extends GoogleVertexAIResponse {
+interface UpsertDatapointResponse extends GoogleResponse {
 }
 declare class UpsertDatapointConnection extends GoogleVertexAIConnection<AsyncCallerCallOptions, UpsertDatapointResponse, GoogleAuthOptions> {
     index: string;

package/dist/vectorstores/pinecone.cjs

@@ -27,11 +27,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PineconeStore = void 0;
+/* eslint-disable no-process-env */
 const uuid = __importStar(require("uuid"));
 const flat_1 = __importDefault(require("flat"));
 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
@@ -135,16 +135,13 @@ class PineconeStore extends base_js_1.VectorStore {
                 values,
             };
         });
+        const namespace = this.pineconeIndex.namespace(this.namespace ?? "");
         // Pinecone recommends a limit of 100 vectors per upsert request
-        const chunkSize = 100;
-        const chunkedVectors = (0, chunk_js_1.chunkArray)(pineconeVectors, chunkSize);
-        const batchRequests = chunkedVectors.map((chunk) => this.caller.call(async () => this.pineconeIndex.upsert({
-            upsertRequest: {
-                vectors: chunk,
-                namespace: this.namespace,
-            },
-        })));
-        await Promise.all(batchRequests);
+        const chunkSize = 50;
+        for (let i = 0; i < pineconeVectors.length; i += chunkSize) {
+            const chunk = pineconeVectors.slice(i, i + chunkSize);
+            await namespace.upsert(chunk);
+        }
         return documentIds;
     }
     /**
@@ -153,23 +150,17 @@ class PineconeStore extends base_js_1.VectorStore {
      * @returns Promise that resolves when the delete operation is complete.
      */
     async delete(params) {
-        const { namespace = this.namespace, deleteAll, ids, ...rest } = params;
+        const { deleteAll, ids } = params;
+        const namespace = this.pineconeIndex.namespace(this.namespace ?? "");
         if (deleteAll) {
-            await this.pineconeIndex.delete1({
-                deleteAll: true,
-                namespace,
-                ...rest,
-            });
+            await namespace.deleteAll();
         }
         else if (ids) {
             const batchSize = 1000;
-            const batchedIds = (0, chunk_js_1.chunkArray)(ids, batchSize);
-            const batchRequests = batchedIds.map((batchIds) => this.caller.call(async () => this.pineconeIndex.delete1({
-                ids: batchIds,
-                namespace,
-                ...rest,
-            })));
-            await Promise.all(batchRequests);
+            for (let i = 0; i < ids.length; i += batchSize) {
+                const batchIds = ids.slice(i, i + batchSize);
+                await namespace.deleteMany(batchIds);
+            }
         }
         else {
             throw new Error("Either ids or delete_all must be provided.");
@@ -188,14 +179,12 @@ class PineconeStore extends base_js_1.VectorStore {
             throw new Error("cannot provide both `filter` and `this.filter`");
         }
         const _filter = filter ?? this.filter;
-        const results = await this.pineconeIndex.query({
-            queryRequest: {
-                includeMetadata: true,
-                namespace: this.namespace,
-                topK: k,
-                vector: query,
-                filter: _filter,
-            },
+        const namespace = this.pineconeIndex.namespace(this.namespace ?? "");
+        const results = await namespace.query({
+            includeMetadata: true,
+            topK: k,
+            vector: query,
+            filter: _filter,
         });
         const result = [];
         if (results.matches) {
@@ -229,9 +218,7 @@ class PineconeStore extends base_js_1.VectorStore {
             docs.push(newDoc);
         }
         const args = {
-            pineconeIndex: "pineconeIndex" in dbConfig
-                ? dbConfig.pineconeIndex
-                : dbConfig.pineconeClient,
+            pineconeIndex: dbConfig.pineconeIndex,
             textKey: dbConfig.textKey,
             namespace: dbConfig.namespace,
         };

package/dist/vectorstores/pinecone.d.ts

@@ -1,11 +1,11 @@
+import { Index as PineconeIndex } from "@pinecone-database/pinecone";
 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";
+import { AsyncCaller } from "../util/async_caller.js";
 type PineconeMetadata = Record<string, any>;
-type VectorOperationsApi = ReturnType<import("@pinecone-database/pinecone").PineconeClient["Index"]>;
-export interface PineconeLibArgs extends AsyncCallerParams {
-    pineconeIndex: VectorOperationsApi;
+export interface PineconeLibArgs {
+    pineconeIndex: PineconeIndex;
     textKey?: string;
     namespace?: string;
     filter?: PineconeMetadata;
@@ -27,7 +27,7 @@ export declare class PineconeStore extends VectorStore {
     FilterType: PineconeMetadata;
     textKey: string;
     namespace?: string;
-    pineconeIndex: VectorOperationsApi;
+    pineconeIndex: PineconeIndex;
     filter?: PineconeMetadata;
     caller: AsyncCaller;
     _vectorstoreType(): string;
@@ -76,10 +76,7 @@ export declare class PineconeStore extends VectorStore {
      * @returns Promise that resolves with a new instance of the PineconeStore class.
      */
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: {
-        /**
-         * @deprecated Use pineconeIndex instead
-         */
-        pineconeClient: VectorOperationsApi;
+        pineconeIndex: PineconeIndex;
         textKey?: string;
         namespace?: string | undefined;
     } | PineconeLibArgs): Promise<PineconeStore>;