modelfusion 0.0.44

package/util/api/throttleMaxConcurrency.d.ts

@@ -0,0 +1,7 @@
+import { ThrottleFunction } from "./ThrottleFunction.js";
+/**
+ * The `throttleMaxConcurrency` strategy limits the number of parallel API calls.
+ */
+export declare function throttleMaxConcurrency({ maxConcurrentCalls, }: {
+    maxConcurrentCalls: number;
+}): ThrottleFunction;

package/util/api/throttleMaxConcurrency.js

@@ -0,0 +1,61 @@
+class MaxConcurrencyThrottler {
+    constructor({ maxConcurrentCalls }) {
+        Object.defineProperty(this, "maxConcurrentCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeCallCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxConcurrentCalls = maxConcurrentCalls;
+        this.activeCallCount = 0;
+        this.callQueue = [];
+    }
+    async run(fn) {
+        return new Promise((resolve, reject) => {
+            const tryExecute = async () => {
+                if (this.activeCallCount >= this.maxConcurrentCalls)
+                    return;
+                // mark as active and remove from queue:
+                this.activeCallCount++;
+                const idx = this.callQueue.indexOf(tryExecute);
+                if (idx !== -1)
+                    this.callQueue.splice(idx, 1);
+                try {
+                    resolve(await fn());
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    this.activeCallCount--;
+                    if (this.callQueue.length > 0) {
+                        this.callQueue[0]();
+                    }
+                }
+            };
+            this.callQueue.push(tryExecute);
+            if (this.activeCallCount < this.maxConcurrentCalls) {
+                tryExecute();
+            }
+        });
+    }
+}
+/**
+ * The `throttleMaxConcurrency` strategy limits the number of parallel API calls.
+ */
+export function throttleMaxConcurrency({ maxConcurrentCalls, }) {
+    const throttler = new MaxConcurrencyThrottler({ maxConcurrentCalls });
+    return (fn) => throttler.run(fn);
+}

package/util/api/throttleUnlimitedConcurrency.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttleUnlimitedConcurrency = void 0;
+/**
+ * The `throttleUnlimitedConcurrency` strategy does not limit parallel API calls.
+ */
+const throttleUnlimitedConcurrency = () => (fn) => fn();
+exports.throttleUnlimitedConcurrency = throttleUnlimitedConcurrency;

package/util/api/throttleUnlimitedConcurrency.d.ts

@@ -0,0 +1,5 @@
+import { ThrottleFunction } from "./ThrottleFunction.js";
+/**
+ * The `throttleUnlimitedConcurrency` strategy does not limit parallel API calls.
+ */
+export declare const throttleUnlimitedConcurrency: () => ThrottleFunction;

package/util/api/throttleUnlimitedConcurrency.js

@@ -0,0 +1,4 @@
+/**
+ * The `throttleUnlimitedConcurrency` strategy does not limit parallel API calls.
+ */
+export const throttleUnlimitedConcurrency = () => (fn) => fn();

package/util/cosineSimilarity.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cosineSimilarity = void 0;
+/**
+ * Calculates the cosine similarity between two vectors. They must have the same length.
+ *
+ * @param a The first vector.
+ * @param b The second vector.
+ *
+ * @returns The cosine similarity between the two vectors.
+ *
+ * @see https://en.wikipedia.org/wiki/Cosine_similarity
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vectors must have the same length (a: ${a.length}, b: ${b.length})`);
+    }
+    return dotProduct(a, b) / (magnitude(a) * magnitude(b));
+}
+exports.cosineSimilarity = cosineSimilarity;
+function dotProduct(a, b) {
+    return a.reduce((acc, val, i) => acc + val * b[i], 0);
+}
+function magnitude(a) {
+    return Math.sqrt(dotProduct(a, a));
+}

package/util/cosineSimilarity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Calculates the cosine similarity between two vectors. They must have the same length.
+ *
+ * @param a The first vector.
+ * @param b The second vector.
+ *
+ * @returns The cosine similarity between the two vectors.
+ *
+ * @see https://en.wikipedia.org/wiki/Cosine_similarity
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;

package/util/cosineSimilarity.js

@@ -0,0 +1,22 @@
+/**
+ * Calculates the cosine similarity between two vectors. They must have the same length.
+ *
+ * @param a The first vector.
+ * @param b The second vector.
+ *
+ * @returns The cosine similarity between the two vectors.
+ *
+ * @see https://en.wikipedia.org/wiki/Cosine_similarity
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vectors must have the same length (a: ${a.length}, b: ${b.length})`);
+    }
+    return dotProduct(a, b) / (magnitude(a) * magnitude(b));
+}
+function dotProduct(a, b) {
+    return a.reduce((acc, val, i) => acc + val * b[i], 0);
+}
+function magnitude(a) {
+    return Math.sqrt(dotProduct(a, a));
+}

package/util/index.cjs

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api/AbortError.cjs"), exports);
+__exportStar(require("./api/ApiCallError.cjs"), exports);
+__exportStar(require("./api/RetryError.cjs"), exports);
+__exportStar(require("./api/RetryFunction.cjs"), exports);
+__exportStar(require("./api/ThrottleFunction.cjs"), exports);
+__exportStar(require("./api/retryNever.cjs"), exports);
+__exportStar(require("./api/retryWithExponentialBackoff.cjs"), exports);
+__exportStar(require("./api/throttleMaxConcurrency.cjs"), exports);
+__exportStar(require("./api/throttleUnlimitedConcurrency.cjs"), exports);
+__exportStar(require("./cosineSimilarity.cjs"), exports);

package/util/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./api/AbortError.js";
+export * from "./api/ApiCallError.js";
+export * from "./api/RetryError.js";
+export * from "./api/RetryFunction.js";
+export * from "./api/ThrottleFunction.js";
+export * from "./api/retryNever.js";
+export * from "./api/retryWithExponentialBackoff.js";
+export * from "./api/throttleMaxConcurrency.js";
+export * from "./api/throttleUnlimitedConcurrency.js";
+export * from "./cosineSimilarity.js";

package/util/index.js

@@ -0,0 +1,10 @@
+export * from "./api/AbortError.js";
+export * from "./api/ApiCallError.js";
+export * from "./api/RetryError.js";
+export * from "./api/RetryFunction.js";
+export * from "./api/ThrottleFunction.js";
+export * from "./api/retryNever.js";
+export * from "./api/retryWithExponentialBackoff.js";
+export * from "./api/throttleMaxConcurrency.js";
+export * from "./api/throttleUnlimitedConcurrency.js";
+export * from "./cosineSimilarity.js";

package/util/never.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.never = void 0;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function never(_) { }
+exports.never = never;

package/util/never.d.ts

@@ -0,0 +1 @@
+export declare function never(_: never): void;

package/util/never.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function never(_) { }

package/util/runSafe.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSafe = void 0;
+const runSafe = async (f) => {
+    try {
+        return { ok: true, output: await f() };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return { ok: false, isAborted: true };
+        }
+        return { ok: false, error };
+    }
+};
+exports.runSafe = runSafe;

package/util/runSafe.d.ts

@@ -0,0 +1,2 @@
+import { SafeResult } from "./SafeResult.js";
+export declare const runSafe: <OUTPUT>(f: () => PromiseLike<OUTPUT>) => Promise<SafeResult<OUTPUT>>;

package/util/runSafe.js

@@ -0,0 +1,11 @@
+export const runSafe = async (f) => {
+    try {
+        return { ok: true, output: await f() };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return { ok: false, isAborted: true };
+        }
+        return { ok: false, error };
+    }
+};

package/vector-index/VectorIndex.cjs

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

package/vector-index/VectorIndex.d.ts

@@ -0,0 +1,18 @@
+import { Vector } from "../run/Vector.js";
+export interface VectorIndex<DATA, INDEX> {
+    upsertMany(data: Array<{
+        id: string;
+        vector: Vector;
+        data: DATA;
+    }>): Promise<void>;
+    queryByVector(options: {
+        queryVector: Vector;
+        maxResults: number;
+        similarityThreshold?: number;
+    }): Promise<Array<{
+        id: string;
+        data: DATA;
+        similarity?: number;
+    }>>;
+    asIndex(): INDEX;
+}

package/vector-index/VectorIndex.js

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

package/vector-index/VectorIndexSimilarTextChunkRetriever.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorIndexSimilarTextChunkRetriever = void 0;
+const embedText_js_1 = require("../model-function/embed-text/embedText.cjs");
+class VectorIndexSimilarTextChunkRetriever {
+    constructor({ vectorIndex, embeddingModel, maxResults, similarityThreshold, }) {
+        Object.defineProperty(this, "vectorIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.vectorIndex = vectorIndex;
+        this.embeddingModel = embeddingModel;
+        this.settings = {
+            maxResults,
+            similarityThreshold,
+        };
+    }
+    async retrieveTextChunks(query, options) {
+        if (options?.settings != null) {
+            return this.withSettings(options.settings).retrieveTextChunks(query, {
+                functionId: options.functionId,
+                run: options.run,
+            });
+        }
+        const { embedding } = await (0, embedText_js_1.embedText)(this.embeddingModel, query, {
+            functionId: options?.functionId,
+            run: options?.run,
+        });
+        const queryResult = await this.vectorIndex.queryByVector({
+            queryVector: embedding,
+            maxResults: this.settings.maxResults ?? 1,
+            similarityThreshold: this.settings.similarityThreshold,
+        });
+        return queryResult.map((item) => item.data);
+    }
+    withSettings(additionalSettings) {
+        return new VectorIndexSimilarTextChunkRetriever(Object.assign({}, this.settings, additionalSettings, {
+            vectorIndex: this.vectorIndex,
+            embeddingModel: this.embeddingModel,
+        }));
+    }
+}
+exports.VectorIndexSimilarTextChunkRetriever = VectorIndexSimilarTextChunkRetriever;

package/vector-index/VectorIndexSimilarTextChunkRetriever.d.ts

@@ -0,0 +1,20 @@
+import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../model-function/embed-text/TextEmbeddingModel.js";
+import { TextChunk } from "../text-chunk/TextChunk.js";
+import { TextChunkRetriever, TextChunkRetrieverSettings } from "../text-chunk/retrieve-text-chunks/TextChunkRetriever.js";
+import { VectorIndex } from "./VectorIndex.js";
+export interface VectorIndexTextChunkRetrieverSettings {
+    maxResults?: number;
+    similarityThreshold?: number;
+}
+export declare class VectorIndexSimilarTextChunkRetriever<CHUNK extends TextChunk, INDEX, SETTINGS extends TextEmbeddingModelSettings> implements TextChunkRetriever<CHUNK, string, VectorIndexTextChunkRetrieverSettings> {
+    private readonly vectorIndex;
+    private readonly embeddingModel;
+    private readonly settings;
+    constructor({ vectorIndex, embeddingModel, maxResults, similarityThreshold, }: {
+        vectorIndex: VectorIndex<CHUNK, INDEX>;
+        embeddingModel: TextEmbeddingModel<unknown, SETTINGS>;
+    } & VectorIndexTextChunkRetrieverSettings);
+    retrieveTextChunks(query: string, options?: FunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
+    withSettings(additionalSettings: Partial<VectorIndexTextChunkRetrieverSettings>): this;
+}

package/vector-index/VectorIndexSimilarTextChunkRetriever.js

@@ -0,0 +1,53 @@
+import { embedText } from "../model-function/embed-text/embedText.js";
+export class VectorIndexSimilarTextChunkRetriever {
+    constructor({ vectorIndex, embeddingModel, maxResults, similarityThreshold, }) {
+        Object.defineProperty(this, "vectorIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.vectorIndex = vectorIndex;
+        this.embeddingModel = embeddingModel;
+        this.settings = {
+            maxResults,
+            similarityThreshold,
+        };
+    }
+    async retrieveTextChunks(query, options) {
+        if (options?.settings != null) {
+            return this.withSettings(options.settings).retrieveTextChunks(query, {
+                functionId: options.functionId,
+                run: options.run,
+            });
+        }
+        const { embedding } = await embedText(this.embeddingModel, query, {
+            functionId: options?.functionId,
+            run: options?.run,
+        });
+        const queryResult = await this.vectorIndex.queryByVector({
+            queryVector: embedding,
+            maxResults: this.settings.maxResults ?? 1,
+            similarityThreshold: this.settings.similarityThreshold,
+        });
+        return queryResult.map((item) => item.data);
+    }
+    withSettings(additionalSettings) {
+        return new VectorIndexSimilarTextChunkRetriever(Object.assign({}, this.settings, additionalSettings, {
+            vectorIndex: this.vectorIndex,
+            embeddingModel: this.embeddingModel,
+        }));
+    }
+}

package/vector-index/VectorIndexTextChunkStore.cjs

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorIndexTextChunkStore = void 0;
+const nanoid_1 = require("nanoid");
+const embedText_js_1 = require("../model-function/embed-text/embedText.cjs");
+class VectorIndexTextChunkStore {
+    constructor({ index, generateId = nanoid_1.nanoid, embeddingModel, queryFunctionId, upsertFunctionId, }) {
+        Object.defineProperty(this, "_index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "generateId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryFunctionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "upsertFunctionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._index = index;
+        this.generateId = generateId;
+        this.embeddingModel = embeddingModel;
+        this.queryFunctionId = queryFunctionId;
+        this.upsertFunctionId = upsertFunctionId;
+    }
+    async upsertChunk({ id = this.generateId(), chunk, }, options) {
+        this.upsertManyChunks({
+            ids: [id],
+            chunks: [chunk],
+        }, options);
+    }
+    async upsertManyChunks({ ids, chunks, }, options) {
+        const { embeddings } = await (0, embedText_js_1.embedTexts)(this.embeddingModel, chunks.map((chunk) => chunk.content), {
+            functionId: this.upsertFunctionId,
+            run: options?.run,
+        });
+        this._index.upsertMany(embeddings.map((embedding, i) => ({
+            id: ids?.[i] ?? this.generateId(),
+            vector: embedding,
+            data: chunks[i],
+        })));
+    }
+    async retrieveSimilarTextChunks(queryText, options) {
+        const { embedding } = await (0, embedText_js_1.embedText)(this.embeddingModel, queryText, {
+            functionId: this.queryFunctionId,
+            run: options?.run,
+        });
+        const queryResult = await this._index.queryByVector({
+            queryVector: embedding,
+            maxResults: 1,
+            similarityThreshold: undefined,
+        });
+        return queryResult.map((item) => item.data);
+    }
+    get index() {
+        return this._index.asIndex();
+    }
+}
+exports.VectorIndexTextChunkStore = VectorIndexTextChunkStore;

package/vector-index/VectorIndexTextChunkStore.d.ts

@@ -0,0 +1,35 @@
+import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../model-function/embed-text/TextEmbeddingModel.js";
+import { Run } from "../run/Run.js";
+import { TextChunk } from "../text-chunk/TextChunk.js";
+import { TextChunkRetrieverSettings } from "../text-chunk/retrieve-text-chunks/TextChunkRetriever.js";
+import { VectorIndex } from "./VectorIndex.js";
+import { FunctionOptions } from "../model-function/FunctionOptions.js";
+export declare class VectorIndexTextChunkStore<CHUNK extends TextChunk, INDEX, MODEL extends TextEmbeddingModel<unknown, TextEmbeddingModelSettings>> {
+    private readonly _index;
+    private readonly generateId;
+    private readonly embeddingModel;
+    private readonly queryFunctionId?;
+    private readonly upsertFunctionId?;
+    constructor({ index, generateId, embeddingModel, queryFunctionId, upsertFunctionId, }: {
+        index: VectorIndex<CHUNK, INDEX>;
+        generateId?: () => string;
+        embeddingModel: MODEL;
+        queryFunctionId?: string;
+        upsertFunctionId?: string;
+    });
+    upsertChunk({ id, chunk, }: {
+        id?: string;
+        keyText: string;
+        chunk: CHUNK;
+    }, options?: {
+        run?: Run;
+    }): Promise<void>;
+    upsertManyChunks({ ids, chunks, }: {
+        ids?: Array<string | undefined>;
+        chunks: CHUNK[];
+    }, options?: {
+        run?: Run;
+    }): Promise<void>;
+    retrieveSimilarTextChunks(queryText: string, options?: FunctionOptions<TextChunkRetrieverSettings> | undefined): Promise<CHUNK[]>;
+    get index(): INDEX;
+}

package/vector-index/VectorIndexTextChunkStore.js

@@ -0,0 +1,73 @@
+import { nanoid as createId } from "nanoid";
+import { embedText, embedTexts, } from "../model-function/embed-text/embedText.js";
+export class VectorIndexTextChunkStore {
+    constructor({ index, generateId = createId, embeddingModel, queryFunctionId, upsertFunctionId, }) {
+        Object.defineProperty(this, "_index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "generateId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryFunctionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "upsertFunctionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._index = index;
+        this.generateId = generateId;
+        this.embeddingModel = embeddingModel;
+        this.queryFunctionId = queryFunctionId;
+        this.upsertFunctionId = upsertFunctionId;
+    }
+    async upsertChunk({ id = this.generateId(), chunk, }, options) {
+        this.upsertManyChunks({
+            ids: [id],
+            chunks: [chunk],
+        }, options);
+    }
+    async upsertManyChunks({ ids, chunks, }, options) {
+        const { embeddings } = await embedTexts(this.embeddingModel, chunks.map((chunk) => chunk.content), {
+            functionId: this.upsertFunctionId,
+            run: options?.run,
+        });
+        this._index.upsertMany(embeddings.map((embedding, i) => ({
+            id: ids?.[i] ?? this.generateId(),
+            vector: embedding,
+            data: chunks[i],
+        })));
+    }
+    async retrieveSimilarTextChunks(queryText, options) {
+        const { embedding } = await embedText(this.embeddingModel, queryText, {
+            functionId: this.queryFunctionId,
+            run: options?.run,
+        });
+        const queryResult = await this._index.queryByVector({
+            queryVector: embedding,
+            maxResults: 1,
+            similarityThreshold: undefined,
+        });
+        return queryResult.map((item) => item.data);
+    }
+    get index() {
+        return this._index.asIndex();
+    }
+}

package/vector-index/index.cjs

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./VectorIndex.cjs"), exports);
+__exportStar(require("./VectorIndexSimilarTextChunkRetriever.cjs"), exports);
+__exportStar(require("./VectorIndexTextChunkStore.cjs"), exports);
+__exportStar(require("./memory/MemoryVectorIndex.cjs"), exports);
+__exportStar(require("./pinecone/PineconeVectorIndex.cjs"), exports);
+__exportStar(require("./upsertTextChunks.cjs"), exports);

package/vector-index/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./VectorIndex.js";
+export * from "./VectorIndexSimilarTextChunkRetriever.js";
+export * from "./VectorIndexTextChunkStore.js";
+export * from "./memory/MemoryVectorIndex.js";
+export * from "./pinecone/PineconeVectorIndex.js";
+export * from "./upsertTextChunks.js";

package/vector-index/index.js

@@ -0,0 +1,6 @@
+export * from "./VectorIndex.js";
+export * from "./VectorIndexSimilarTextChunkRetriever.js";
+export * from "./VectorIndexTextChunkStore.js";
+export * from "./memory/MemoryVectorIndex.js";
+export * from "./pinecone/PineconeVectorIndex.js";
+export * from "./upsertTextChunks.js";