modelfusion 0.133.0 → 0.134.0

package/util/streaming/parseEventSourceStreamAsAsyncIterable.js

@@ -1,48 +0,0 @@
-import { safeParseJSON } from "../../core/schema/parseJSON.js";
-import { AsyncQueue } from "../AsyncQueue.js";
-import { parseEventSourceStream } from "./parseEventSourceStream.js";
-export async function parseEventSourceStreamAsAsyncIterable({ stream, schema, }) {
-    const queue = new AsyncQueue();
-    // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceStream({ stream })
-        .then(async (events) => {
-        try {
-            for await (const event of events) {
-                const data = event.data;
-                if (data === "[DONE]") {
-                    queue.close();
-                    return;
-                }
-                const parseResult = safeParseJSON({
-                    text: data,
-                    schema,
-                });
-                if (!parseResult.success) {
-                    queue.push({
-                        type: "error",
-                        error: parseResult.error,
-                    });
-                    // Note: the queue is not closed on purpose. Some providers might add additional
-                    // chunks that are not parsable, and ModelFusion should be resilient to that.
-                    continue;
-                }
-                const completionChunk = parseResult.value;
-                queue.push({
-                    type: "delta",
-                    deltaValue: completionChunk,
-                });
-            }
-        }
-        catch (error) {
-            queue.push({ type: "error", error });
-            queue.close();
-            return;
-        }
-    })
-        .catch((error) => {
-        queue.push({ type: "error", error });
-        queue.close();
-        return;
-    });
-    return queue;
-}

package/util/streaming/parseJsonStream.cjs

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonStream = void 0;
-const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
-function parseJsonStream({ schema, stream, process, onDone, }) {
-    function processLine(line) {
-        process((0, parseJSON_js_1.parseJSON)({ text: line, schema }));
-    }
-    return (async () => {
-        try {
-            const reader = new ReadableStreamDefaultReader(stream);
-            const utf8Decoder = new TextDecoder("utf-8");
-            let unprocessedText = "";
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const { value: chunk, done } = await reader.read();
-                if (done) {
-                    break;
-                }
-                unprocessedText += utf8Decoder.decode(chunk, { stream: true });
-                const processableLines = unprocessedText.split("\n");
-                unprocessedText = processableLines.pop() ?? "";
-                processableLines.forEach(processLine);
-            }
-            // processing remaining text:
-            if (unprocessedText) {
-                processLine(unprocessedText);
-            }
-        }
-        finally {
-            onDone?.();
-        }
-    })();
-}
-exports.parseJsonStream = parseJsonStream;

package/util/streaming/parseJsonStream.d.ts

@@ -1,7 +0,0 @@
-import { Schema } from "../../core/schema/Schema.js";
-export declare function parseJsonStream<T>({ schema, stream, process, onDone, }: {
-    schema: Schema<T>;
-    stream: ReadableStream<Uint8Array>;
-    process: (event: T) => void;
-    onDone?: () => void;
-}): Promise<void>;

package/util/streaming/parseJsonStream.js

@@ -1,31 +0,0 @@
-import { parseJSON } from "../../core/schema/parseJSON.js";
-export function parseJsonStream({ schema, stream, process, onDone, }) {
-    function processLine(line) {
-        process(parseJSON({ text: line, schema }));
-    }
-    return (async () => {
-        try {
-            const reader = new ReadableStreamDefaultReader(stream);
-            const utf8Decoder = new TextDecoder("utf-8");
-            let unprocessedText = "";
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const { value: chunk, done } = await reader.read();
-                if (done) {
-                    break;
-                }
-                unprocessedText += utf8Decoder.decode(chunk, { stream: true });
-                const processableLines = unprocessedText.split("\n");
-                unprocessedText = processableLines.pop() ?? "";
-                processableLines.forEach(processLine);
-            }
-            // processing remaining text:
-            if (unprocessedText) {
-                processLine(unprocessedText);
-            }
-        }
-        finally {
-            onDone?.();
-        }
-    })();
-}

package/util/streaming/parseJsonStreamAsAsyncIterable.cjs

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonStreamAsAsyncIterable = void 0;
-const AsyncQueue_js_1 = require("../AsyncQueue.cjs");
-const parseJsonStream_js_1 = require("./parseJsonStream.cjs");
-async function parseJsonStreamAsAsyncIterable({ stream, schema, }) {
-    const queue = new AsyncQueue_js_1.AsyncQueue();
-    // process the stream asynchonously (no 'await' on purpose):
-    (0, parseJsonStream_js_1.parseJsonStream)({
-        stream,
-        schema,
-        process(event) {
-            queue.push({ type: "delta", deltaValue: event });
-        },
-        onDone() {
-            queue.close();
-        },
-    });
-    return queue;
-}
-exports.parseJsonStreamAsAsyncIterable = parseJsonStreamAsAsyncIterable;

package/util/streaming/parseJsonStreamAsAsyncIterable.d.ts

@@ -1,6 +0,0 @@
-import { Schema } from "../../core/schema/Schema.js";
-import { Delta } from "../../model-function/Delta.js";
-export declare function parseJsonStreamAsAsyncIterable<T>({ stream, schema, }: {
-    stream: ReadableStream<Uint8Array>;
-    schema: Schema<T>;
-}): Promise<AsyncIterable<Delta<T>>>;

package/util/streaming/parseJsonStreamAsAsyncIterable.js

@@ -1,17 +0,0 @@
-import { AsyncQueue } from "../AsyncQueue.js";
-import { parseJsonStream } from "./parseJsonStream.js";
-export async function parseJsonStreamAsAsyncIterable({ stream, schema, }) {
-    const queue = new AsyncQueue();
-    // process the stream asynchonously (no 'await' on purpose):
-    parseJsonStream({
-        stream,
-        schema,
-        process(event) {
-            queue.push({ type: "delta", deltaValue: event });
-        },
-        onDone() {
-            queue.close();
-        },
-    });
-    return queue;
-}

package/vector-index/UpsertIntoVectorIndexEvent.cjs

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

package/vector-index/UpsertIntoVectorIndexEvent.d.ts

@@ -1,9 +0,0 @@
-import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
-export interface UpsertIntoVectorIndexStartedEvent extends BaseFunctionStartedEvent {
-    functionType: "upsert-into-vector-index";
-    objects: unknown[];
-}
-export interface UpsertIntoVectorIndexFinishedEvent extends BaseFunctionFinishedEvent {
-    functionType: "upsert-into-vector-index";
-    objects: unknown[];
-}

package/vector-index/UpsertIntoVectorIndexEvent.js

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

package/vector-index/VectorIndex.cjs

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

package/vector-index/VectorIndex.d.ts

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

package/vector-index/VectorIndex.js

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

package/vector-index/VectorIndexRetriever.cjs

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VectorIndexRetriever = void 0;
-const embed_js_1 = require("../model-function/embed/embed.cjs");
-class VectorIndexRetriever {
-    constructor({ vectorIndex, embeddingModel, maxResults, similarityThreshold, filter, }) {
-        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,
-            filter,
-        };
-    }
-    async retrieve(query, options) {
-        const embedding = await (0, embed_js_1.embed)({
-            model: this.embeddingModel,
-            value: query,
-            ...options,
-        });
-        const queryResult = await this.vectorIndex.queryByVector({
-            queryVector: embedding,
-            maxResults: this.settings.maxResults ?? 1,
-            similarityThreshold: this.settings.similarityThreshold,
-            filter: this.settings?.filter,
-        });
-        return queryResult.map((item) => item.data);
-    }
-    withSettings(additionalSettings) {
-        return new VectorIndexRetriever(Object.assign({}, this.settings, additionalSettings, {
-            vectorIndex: this.vectorIndex,
-            embeddingModel: this.embeddingModel,
-        }));
-    }
-}
-exports.VectorIndexRetriever = VectorIndexRetriever;

package/vector-index/VectorIndexRetriever.d.ts

@@ -1,20 +0,0 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
-import { EmbeddingModel, EmbeddingModelSettings } from "../model-function/embed/EmbeddingModel.js";
-import { Retriever } from "../retriever/Retriever.js";
-import { VectorIndex } from "./VectorIndex.js";
-export interface VectorIndexRetrieverSettings<FILTER> {
-    maxResults?: number;
-    similarityThreshold?: number;
-    filter?: FILTER;
-}
-export declare class VectorIndexRetriever<OBJECT, VALUE, INDEX, FILTER> implements Retriever<OBJECT, VALUE> {
-    private readonly vectorIndex;
-    private readonly embeddingModel;
-    private readonly settings;
-    constructor({ vectorIndex, embeddingModel, maxResults, similarityThreshold, filter, }: {
-        vectorIndex: VectorIndex<OBJECT, INDEX, FILTER>;
-        embeddingModel: EmbeddingModel<VALUE, EmbeddingModelSettings>;
-    } & VectorIndexRetrieverSettings<FILTER>);
-    retrieve(query: VALUE, options?: FunctionOptions): Promise<OBJECT[]>;
-    withSettings(additionalSettings: Partial<VectorIndexRetrieverSettings<FILTER>>): this;
-}

package/vector-index/VectorIndexRetriever.js

@@ -1,50 +0,0 @@
-import { embed } from "../model-function/embed/embed.js";
-export class VectorIndexRetriever {
-    constructor({ vectorIndex, embeddingModel, maxResults, similarityThreshold, filter, }) {
-        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,
-            filter,
-        };
-    }
-    async retrieve(query, options) {
-        const embedding = await embed({
-            model: this.embeddingModel,
-            value: query,
-            ...options,
-        });
-        const queryResult = await this.vectorIndex.queryByVector({
-            queryVector: embedding,
-            maxResults: this.settings.maxResults ?? 1,
-            similarityThreshold: this.settings.similarityThreshold,
-            filter: this.settings?.filter,
-        });
-        return queryResult.map((item) => item.data);
-    }
-    withSettings(additionalSettings) {
-        return new VectorIndexRetriever(Object.assign({}, this.settings, additionalSettings, {
-            vectorIndex: this.vectorIndex,
-            embeddingModel: this.embeddingModel,
-        }));
-    }
-}

package/vector-index/index.cjs

@@ -1,21 +0,0 @@
-"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("./UpsertIntoVectorIndexEvent.cjs"), exports);
-__exportStar(require("./VectorIndex.cjs"), exports);
-__exportStar(require("./VectorIndexRetriever.cjs"), exports);
-__exportStar(require("./memory/MemoryVectorIndex.cjs"), exports);
-__exportStar(require("./upsertIntoVectorIndex.cjs"), exports);

package/vector-index/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./UpsertIntoVectorIndexEvent.js";
-export * from "./VectorIndex.js";
-export * from "./VectorIndexRetriever.js";
-export * from "./memory/MemoryVectorIndex.js";
-export * from "./upsertIntoVectorIndex.js";

package/vector-index/index.js

@@ -1,5 +0,0 @@
-export * from "./UpsertIntoVectorIndexEvent.js";
-export * from "./VectorIndex.js";
-export * from "./VectorIndexRetriever.js";
-export * from "./memory/MemoryVectorIndex.js";
-export * from "./upsertIntoVectorIndex.js";

package/vector-index/memory/MemoryVectorIndex.cjs

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryVectorIndex = void 0;
-const zod_1 = require("zod");
-const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
-const cosineSimilarity_js_1 = require("../../util/cosineSimilarity.cjs");
-const jsonDataSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.array(zod_1.z.object({
-    id: zod_1.z.string(),
-    vector: zod_1.z.array(zod_1.z.number()),
-    data: zod_1.z.unknown(),
-})));
-/**
- * A very simple vector index that stores all entries in memory. Useful when you only have
- * a small number of entries and don't want to set up a real database, e.g. for conversational memory
- * that does not need to be persisted.
- */
-class MemoryVectorIndex {
-    constructor() {
-        Object.defineProperty(this, "entries", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    static async deserialize({ serializedData, schema, }) {
-        // validate the outer value:
-        const json = (0, parseJSON_js_1.parseJSON)({ text: serializedData, schema: jsonDataSchema });
-        if (schema != null) {
-            // when a schema is provided, validate all entries:
-            for (const entry of json) {
-                const validationResult = schema.validate(entry.data);
-                if (!validationResult.success) {
-                    throw validationResult.error;
-                }
-            }
-        }
-        const vectorIndex = new MemoryVectorIndex();
-        vectorIndex.upsertMany(json);
-        return vectorIndex;
-    }
-    async upsertMany(data) {
-        for (const entry of data) {
-            this.entries.set(entry.id, entry);
-        }
-    }
-    async queryByVector({ queryVector, similarityThreshold, maxResults, filter, }) {
-        const results = [...this.entries.values()]
-            .filter((value) => filter?.(value.data) ?? true)
-            .map((entry) => ({
-            id: entry.id,
-            similarity: (0, cosineSimilarity_js_1.cosineSimilarity)(entry.vector, queryVector),
-            data: entry.data,
-        }))
-            .filter((entry) => similarityThreshold == undefined ||
-            entry.similarity == undefined ||
-            entry.similarity > similarityThreshold);
-        results.sort((a, b) => b.similarity - a.similarity);
-        return results.slice(0, maxResults);
-    }
-    serialize() {
-        return JSON.stringify([...this.entries.values()]);
-    }
-    asIndex() {
-        return this;
-    }
-}
-exports.MemoryVectorIndex = MemoryVectorIndex;

package/vector-index/memory/MemoryVectorIndex.d.ts

@@ -1,32 +0,0 @@
-import { Vector } from "../../core/Vector.js";
-import { Schema } from "../../core/schema/Schema.js";
-import { VectorIndex } from "../VectorIndex.js";
-/**
- * A very simple vector index that stores all entries in memory. Useful when you only have
- * a small number of entries and don't want to set up a real database, e.g. for conversational memory
- * that does not need to be persisted.
- */
-export declare class MemoryVectorIndex<DATA> implements VectorIndex<DATA, MemoryVectorIndex<DATA>, (value: DATA) => boolean> {
-    static deserialize<DATA>({ serializedData, schema, }: {
-        serializedData: string;
-        schema?: Schema<DATA>;
-    }): Promise<MemoryVectorIndex<DATA>>;
-    private readonly entries;
-    upsertMany(data: Array<{
-        id: string;
-        vector: Vector;
-        data: DATA;
-    }>): Promise<void>;
-    queryByVector({ queryVector, similarityThreshold, maxResults, filter, }: {
-        queryVector: Vector;
-        maxResults: number;
-        similarityThreshold?: number;
-        filter?: (value: DATA) => boolean;
-    }): Promise<Array<{
-        id: string;
-        data: DATA;
-        similarity?: number;
-    }>>;
-    serialize(): string;
-    asIndex(): MemoryVectorIndex<DATA>;
-}

package/vector-index/memory/MemoryVectorIndex.js

@@ -1,65 +0,0 @@
-import { z } from "zod";
-import { zodSchema } from "../../core/schema/ZodSchema.js";
-import { parseJSON } from "../../core/schema/parseJSON.js";
-import { cosineSimilarity } from "../../util/cosineSimilarity.js";
-const jsonDataSchema = zodSchema(z.array(z.object({
-    id: z.string(),
-    vector: z.array(z.number()),
-    data: z.unknown(),
-})));
-/**
- * A very simple vector index that stores all entries in memory. Useful when you only have
- * a small number of entries and don't want to set up a real database, e.g. for conversational memory
- * that does not need to be persisted.
- */
-export class MemoryVectorIndex {
-    constructor() {
-        Object.defineProperty(this, "entries", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    static async deserialize({ serializedData, schema, }) {
-        // validate the outer value:
-        const json = parseJSON({ text: serializedData, schema: jsonDataSchema });
-        if (schema != null) {
-            // when a schema is provided, validate all entries:
-            for (const entry of json) {
-                const validationResult = schema.validate(entry.data);
-                if (!validationResult.success) {
-                    throw validationResult.error;
-                }
-            }
-        }
-        const vectorIndex = new MemoryVectorIndex();
-        vectorIndex.upsertMany(json);
-        return vectorIndex;
-    }
-    async upsertMany(data) {
-        for (const entry of data) {
-            this.entries.set(entry.id, entry);
-        }
-    }
-    async queryByVector({ queryVector, similarityThreshold, maxResults, filter, }) {
-        const results = [...this.entries.values()]
-            .filter((value) => filter?.(value.data) ?? true)
-            .map((entry) => ({
-            id: entry.id,
-            similarity: cosineSimilarity(entry.vector, queryVector),
-            data: entry.data,
-        }))
-            .filter((entry) => similarityThreshold == undefined ||
-            entry.similarity == undefined ||
-            entry.similarity > similarityThreshold);
-        results.sort((a, b) => b.similarity - a.similarity);
-        return results.slice(0, maxResults);
-    }
-    serialize() {
-        return JSON.stringify([...this.entries.values()]);
-    }
-    asIndex() {
-        return this;
-    }
-}

package/vector-index/upsertIntoVectorIndex.cjs

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.upsertIntoVectorIndex = void 0;
-const nanoid_1 = require("nanoid");
-const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
-const embed_js_1 = require("../model-function/embed/embed.cjs");
-async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId = nanoid_1.nanoid, objects, getValueToEmbed, getId, }, options) {
-    return (0, executeFunctionCall_js_1.executeFunctionCall)({
-        options,
-        input: objects,
-        functionType: "upsert-into-vector-index",
-        inputPropertyName: "objects",
-        execute: async (options) => {
-            // many embedding models support bulk embedding, so we first embed all texts:
-            const embeddings = await (0, embed_js_1.embedMany)({
-                model: embeddingModel,
-                values: objects.map(getValueToEmbed),
-                ...options,
-            });
-            await vectorIndex.upsertMany(objects.map((object, i) => ({
-                id: getId?.(object, i) ?? generateId(),
-                vector: embeddings[i],
-                data: object,
-            })));
-        },
-    });
-}
-exports.upsertIntoVectorIndex = upsertIntoVectorIndex;

package/vector-index/upsertIntoVectorIndex.d.ts

@@ -1,11 +0,0 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
-import { EmbeddingModel, EmbeddingModelSettings } from "../model-function/embed/EmbeddingModel.js";
-import { VectorIndex } from "./VectorIndex.js";
-export declare function upsertIntoVectorIndex<VALUE, OBJECT>({ vectorIndex, embeddingModel, generateId, objects, getValueToEmbed, getId, }: {
-    vectorIndex: VectorIndex<OBJECT, unknown, unknown>;
-    embeddingModel: EmbeddingModel<VALUE, EmbeddingModelSettings>;
-    generateId?: () => string;
-    objects: OBJECT[];
-    getValueToEmbed: (object: OBJECT, index: number) => VALUE;
-    getId?: (object: OBJECT, index: number) => string | undefined;
-}, options?: FunctionOptions): Promise<void>;

package/vector-index/upsertIntoVectorIndex.js

@@ -1,24 +0,0 @@
-import { nanoid as createId } from "nanoid";
-import { executeFunctionCall } from "../core/executeFunctionCall.js";
-import { embedMany } from "../model-function/embed/embed.js";
-export async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId = createId, objects, getValueToEmbed, getId, }, options) {
-    return executeFunctionCall({
-        options,
-        input: objects,
-        functionType: "upsert-into-vector-index",
-        inputPropertyName: "objects",
-        execute: async (options) => {
-            // many embedding models support bulk embedding, so we first embed all texts:
-            const embeddings = await embedMany({
-                model: embeddingModel,
-                values: objects.map(getValueToEmbed),
-                ...options,
-            });
-            await vectorIndex.upsertMany(objects.map((object, i) => ({
-                id: getId?.(object, i) ?? generateId(),
-                vector: embeddings[i],
-                data: object,
-            })));
-        },
-    });
-}