modelfusion 0.132.0 → 0.134.0

package/model-function/embed/EmbeddingModel.d.ts

@@ -1,23 +0,0 @@
-import { FunctionCallOptions } from "../../core/FunctionOptions.js";
-import { Vector } from "../../core/Vector.js";
-import { Model, ModelSettings } from "../Model.js";
-export interface EmbeddingModelSettings extends ModelSettings {
-}
-export interface EmbeddingModel<VALUE, SETTINGS extends EmbeddingModelSettings = EmbeddingModelSettings> extends Model<SETTINGS> {
-    /**
-     * The size of the embedding vector.
-     */
-    readonly embeddingDimensions: number | undefined;
-    /**
-     * Limit of how many values can be sent in a single API call.
-     */
-    readonly maxValuesPerCall: number | undefined;
-    /**
-     * True if the model can handle multiple embedding calls in parallel.
-     */
-    readonly isParallelizable: boolean;
-    doEmbedValues(values: VALUE[], options: FunctionCallOptions): PromiseLike<{
-        rawResponse: unknown;
-        embeddings: Vector[];
-    }>;
-}

package/model-function/embed/EmbeddingModel.js

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

package/model-function/embed/embed.cjs

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.embed = exports.embedMany = void 0;
-const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-async function embedMany({ model, values, fullResponse, ...options }) {
-    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "embed",
-        input: values,
-        model,
-        options,
-        generateResponse: async (options) => {
-            // split the values into groups that are small enough to be sent in one call:
-            const maxValuesPerCall = model.maxValuesPerCall;
-            const valueGroups = [];
-            if (maxValuesPerCall == null) {
-                valueGroups.push(values);
-            }
-            else {
-                for (let i = 0; i < values.length; i += maxValuesPerCall) {
-                    valueGroups.push(values.slice(i, i + maxValuesPerCall));
-                }
-            }
-            // call the model for each group:
-            let responses;
-            if (model.isParallelizable) {
-                responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
-            }
-            else {
-                responses = [];
-                for (const valueGroup of valueGroups) {
-                    const response = await model.doEmbedValues(valueGroup, options);
-                    responses.push(response);
-                }
-            }
-            const rawResponses = responses.map((response) => response.rawResponse);
-            const embeddings = [];
-            for (const response of responses) {
-                embeddings.push(...response.embeddings);
-            }
-            return {
-                rawResponse: rawResponses,
-                extractedValue: embeddings,
-            };
-        },
-    });
-    return fullResponse
-        ? {
-            embeddings: callResponse.value,
-            rawResponse: callResponse.rawResponse,
-            metadata: callResponse.metadata,
-        }
-        : callResponse.value;
-}
-exports.embedMany = embedMany;
-async function embed({ model, value, fullResponse, ...options }) {
-    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "embed",
-        input: value,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doEmbedValues([value], options);
-            return {
-                rawResponse: result.rawResponse,
-                extractedValue: result.embeddings[0],
-            };
-        },
-    });
-    return fullResponse
-        ? {
-            embedding: callResponse.value,
-            rawResponse: callResponse.rawResponse,
-            metadata: callResponse.metadata,
-        }
-        : callResponse.value;
-}
-exports.embed = embed;

package/model-function/embed/embed.d.ts

@@ -1,67 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { Vector } from "../../core/Vector.js";
-import { ModelCallMetadata } from "../ModelCallMetadata.js";
-import { EmbeddingModel, EmbeddingModelSettings } from "./EmbeddingModel.js";
-/**
- * Generate embeddings for multiple values.
- *
- * @see https://modelfusion.dev/guide/function/embed
- *
- * @example
- * const embeddings = await embedMany({
- *   embedder: openai.TextEmbedder(...),
- *   values: [
- *     "At first, Nox didn't know what to do with the pup.",
- *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
- *   ]
- * });
- *
- * @param {EmbeddingModel<VALUE, EmbeddingModelSettings>} model - The model to use for generating embeddings.
- * @param {VALUE[]} values - The values to generate embeddings for.
- *
- * @returns {Promise<Vector[]>} - A promise that resolves to an array of vectors representing the embeddings.
- */
-export declare function embedMany<VALUE>(args: {
-    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
-    values: VALUE[];
-    fullResponse?: false;
-} & FunctionOptions): Promise<Vector[]>;
-export declare function embedMany<VALUE>(args: {
-    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
-    values: VALUE[];
-    fullResponse: true;
-} & FunctionOptions): Promise<{
-    embeddings: Vector[];
-    rawResponse: unknown;
-    metadata: ModelCallMetadata;
-}>;
-/**
- * Generate an embedding for a single value.
- *
- * @see https://modelfusion.dev/guide/function/embed
- *
- * @example
- * const embedding = await embed({
- *   model: openai.TextEmbedder(...),
- *   value: "At first, Nox didn't know what to do with the pup."
- * });
- *
- * @param {EmbeddingModel<VALUE, EmbeddingModelSettings>} model - The model to use for generating the embedding.
- * @param {VALUE} value - The value to generate an embedding for.
- *
- * @returns {Promise<Vector>} - A promise that resolves to a vector representing the embedding.
- */
-export declare function embed<VALUE>(args: {
-    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
-    value: VALUE;
-    fullResponse?: false;
-} & FunctionOptions): Promise<Vector>;
-export declare function embed<VALUE>(args: {
-    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
-    value: VALUE;
-    fullResponse: true;
-} & FunctionOptions): Promise<{
-    embedding: Vector;
-    rawResponse: unknown;
-    metadata: ModelCallMetadata;
-}>;

package/model-function/embed/embed.js

@@ -1,72 +0,0 @@
-import { executeStandardCall } from "../executeStandardCall.js";
-export async function embedMany({ model, values, fullResponse, ...options }) {
-    const callResponse = await executeStandardCall({
-        functionType: "embed",
-        input: values,
-        model,
-        options,
-        generateResponse: async (options) => {
-            // split the values into groups that are small enough to be sent in one call:
-            const maxValuesPerCall = model.maxValuesPerCall;
-            const valueGroups = [];
-            if (maxValuesPerCall == null) {
-                valueGroups.push(values);
-            }
-            else {
-                for (let i = 0; i < values.length; i += maxValuesPerCall) {
-                    valueGroups.push(values.slice(i, i + maxValuesPerCall));
-                }
-            }
-            // call the model for each group:
-            let responses;
-            if (model.isParallelizable) {
-                responses = await Promise.all(valueGroups.map((valueGroup) => model.doEmbedValues(valueGroup, options)));
-            }
-            else {
-                responses = [];
-                for (const valueGroup of valueGroups) {
-                    const response = await model.doEmbedValues(valueGroup, options);
-                    responses.push(response);
-                }
-            }
-            const rawResponses = responses.map((response) => response.rawResponse);
-            const embeddings = [];
-            for (const response of responses) {
-                embeddings.push(...response.embeddings);
-            }
-            return {
-                rawResponse: rawResponses,
-                extractedValue: embeddings,
-            };
-        },
-    });
-    return fullResponse
-        ? {
-            embeddings: callResponse.value,
-            rawResponse: callResponse.rawResponse,
-            metadata: callResponse.metadata,
-        }
-        : callResponse.value;
-}
-export async function embed({ model, value, fullResponse, ...options }) {
-    const callResponse = await executeStandardCall({
-        functionType: "embed",
-        input: value,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doEmbedValues([value], options);
-            return {
-                rawResponse: result.rawResponse,
-                extractedValue: result.embeddings[0],
-            };
-        },
-    });
-    return fullResponse
-        ? {
-            embedding: callResponse.value,
-            rawResponse: callResponse.rawResponse,
-            metadata: callResponse.metadata,
-        }
-        : callResponse.value;
-}

package/model-function/executeStandardCall.cjs

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeStandardCall = void 0;
-const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
-const ModelFusionConfiguration_js_1 = require("../core/ModelFusionConfiguration.cjs");
-const ModelFusionConfiguration_js_2 = require("../core/ModelFusionConfiguration.cjs");
-const AbortError_js_1 = require("../core/api/AbortError.cjs");
-const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
-const getRun_js_1 = require("../core/getRun.cjs");
-const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
-const runSafe_js_1 = require("../util/runSafe.cjs");
-async function executeStandardCall({ model, options, input, functionType, generateResponse, }) {
-    const run = await (0, getRun_js_1.getRun)(options?.run);
-    const settings = model.settings;
-    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
-        observers: [
-            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, ModelFusionConfiguration_js_1.getLogFormat)()),
-            ...(0, ModelFusionConfiguration_js_2.getFunctionObservers)(),
-            ...(settings.observers ?? []),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
-    const startMetadata = {
-        functionType,
-        callId: `call-${(0, nanoid_1.nanoid)()}`,
-        parentCallId: options?.callId,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        model: model.modelInformation,
-        settings: model.settingsForEvent,
-        input,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
-        functionType,
-        functionId: options?.functionId,
-        callId: startMetadata.callId,
-        logging: options?.logging,
-        observers: options?.observers,
-        cache: options?.cache,
-        run,
-    }));
-    const finishMetadata = {
-        eventType: "finished",
-        ...startMetadata,
-        finishTimestamp: new Date(),
-        durationInMs: durationMeasurement.durationInMs,
-    };
-    if (!result.ok) {
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                eventType: "finished",
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError_js_1.AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            eventType: "finished",
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    const rawResponse = result.value.rawResponse;
-    const value = result.value.extractedValue;
-    const usage = result.value.usage;
-    eventSource.notify({
-        ...finishMetadata,
-        eventType: "finished",
-        result: {
-            status: "success",
-            usage,
-            rawResponse,
-            value,
-        },
-    });
-    return {
-        value,
-        rawResponse,
-        metadata: {
-            model: model.modelInformation,
-            callId: finishMetadata.callId,
-            runId: finishMetadata.runId,
-            sessionId: finishMetadata.sessionId,
-            userId: finishMetadata.userId,
-            functionId: finishMetadata.functionId,
-            startTimestamp: startMetadata.startTimestamp,
-            finishTimestamp: finishMetadata.finishTimestamp,
-            durationInMs: finishMetadata.durationInMs,
-            usage,
-        },
-    };
-}
-exports.executeStandardCall = executeStandardCall;

package/model-function/executeStandardCall.d.ts

@@ -1,19 +0,0 @@
-import { FunctionCallOptions, FunctionOptions } from "../core/FunctionOptions.js";
-import { Model, ModelSettings } from "./Model.js";
-import { ModelCallStartedEvent } from "./ModelCallEvent.js";
-import { ModelCallMetadata } from "./ModelCallMetadata.js";
-export declare function executeStandardCall<VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, generateResponse, }: {
-    model: MODEL;
-    options?: FunctionOptions;
-    input: unknown;
-    functionType: ModelCallStartedEvent["functionType"];
-    generateResponse: (options: FunctionCallOptions) => PromiseLike<{
-        rawResponse: unknown;
-        extractedValue: VALUE;
-        usage?: unknown;
-    }>;
-}): Promise<{
-    value: VALUE;
-    rawResponse: unknown;
-    metadata: ModelCallMetadata;
-}>;

package/model-function/executeStandardCall.js

@@ -1,107 +0,0 @@
-import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../core/FunctionEventSource.js";
-import { getLogFormat } from "../core/ModelFusionConfiguration.js";
-import { getFunctionObservers } from "../core/ModelFusionConfiguration.js";
-import { AbortError } from "../core/api/AbortError.js";
-import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
-import { getRun } from "../core/getRun.js";
-import { startDurationMeasurement } from "../util/DurationMeasurement.js";
-import { runSafe } from "../util/runSafe.js";
-export async function executeStandardCall({ model, options, input, functionType, generateResponse, }) {
-    const run = await getRun(options?.run);
-    const settings = model.settings;
-    const eventSource = new FunctionEventSource({
-        observers: [
-            ...getFunctionCallLogger(options?.logging ?? getLogFormat()),
-            ...getFunctionObservers(),
-            ...(settings.observers ?? []),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = startDurationMeasurement();
-    const startMetadata = {
-        functionType,
-        callId: `call-${createId()}`,
-        parentCallId: options?.callId,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        model: model.modelInformation,
-        settings: model.settingsForEvent,
-        input,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await runSafe(() => generateResponse({
-        functionType,
-        functionId: options?.functionId,
-        callId: startMetadata.callId,
-        logging: options?.logging,
-        observers: options?.observers,
-        cache: options?.cache,
-        run,
-    }));
-    const finishMetadata = {
-        eventType: "finished",
-        ...startMetadata,
-        finishTimestamp: new Date(),
-        durationInMs: durationMeasurement.durationInMs,
-    };
-    if (!result.ok) {
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                eventType: "finished",
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            eventType: "finished",
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    const rawResponse = result.value.rawResponse;
-    const value = result.value.extractedValue;
-    const usage = result.value.usage;
-    eventSource.notify({
-        ...finishMetadata,
-        eventType: "finished",
-        result: {
-            status: "success",
-            usage,
-            rawResponse,
-            value,
-        },
-    });
-    return {
-        value,
-        rawResponse,
-        metadata: {
-            model: model.modelInformation,
-            callId: finishMetadata.callId,
-            runId: finishMetadata.runId,
-            sessionId: finishMetadata.sessionId,
-            userId: finishMetadata.userId,
-            functionId: finishMetadata.functionId,
-            startTimestamp: startMetadata.startTimestamp,
-            finishTimestamp: finishMetadata.finishTimestamp,
-            durationInMs: finishMetadata.durationInMs,
-            usage,
-        },
-    };
-}

package/model-function/executeStreamCall.cjs

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeStreamCall = void 0;
-const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
-const ModelFusionConfiguration_js_1 = require("../core/ModelFusionConfiguration.cjs");
-const ModelFusionConfiguration_js_2 = require("../core/ModelFusionConfiguration.cjs");
-const AbortError_js_1 = require("../core/api/AbortError.cjs");
-const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
-const getRun_js_1 = require("../core/getRun.cjs");
-const AsyncQueue_js_1 = require("../util/AsyncQueue.cjs");
-const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
-const runSafe_js_1 = require("../util/runSafe.cjs");
-async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, onDone, }) {
-    const run = await (0, getRun_js_1.getRun)(options?.run);
-    const settings = model.settings;
-    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
-        observers: [
-            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, ModelFusionConfiguration_js_1.getLogFormat)()),
-            ...(0, ModelFusionConfiguration_js_2.getFunctionObservers)(),
-            ...(settings.observers ?? []),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
-    const startMetadata = {
-        functionType,
-        callId: `call-${(0, nanoid_1.nanoid)()}`,
-        parentCallId: options?.callId,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        model: model.modelInformation,
-        settings: model.settingsForEvent,
-        input,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await (0, runSafe_js_1.runSafe)(async () => {
-        const deltaIterable = await startStream({
-            functionType,
-            functionId: options?.functionId,
-            callId: startMetadata.callId,
-            logging: options?.logging,
-            observers: options?.observers,
-            run,
-        });
-        // Return a queue that can be iterated over several times:
-        const responseQueue = new AsyncQueue_js_1.AsyncQueue();
-        // run async:
-        (async function () {
-            try {
-                const loopResult = await (0, runSafe_js_1.runSafe)(async () => {
-                    for await (const event of deltaIterable) {
-                        if (event?.type === "error") {
-                            const error = event.error;
-                            const finishMetadata = {
-                                eventType: "finished",
-                                ...startMetadata,
-                                finishTimestamp: new Date(),
-                                durationInMs: durationMeasurement.durationInMs,
-                            };
-                            eventSource.notify(error instanceof AbortError_js_1.AbortError
-                                ? {
-                                    ...finishMetadata,
-                                    result: { status: "abort" },
-                                }
-                                : {
-                                    ...finishMetadata,
-                                    result: { status: "error", error },
-                                });
-                            throw error;
-                        }
-                        if (event?.type === "delta") {
-                            const value = processDelta(event);
-                            if (value !== undefined) {
-                                responseQueue.push(value);
-                            }
-                        }
-                    }
-                    if (processFinished != null) {
-                        const value = processFinished();
-                        if (value !== undefined) {
-                            responseQueue.push(value);
-                        }
-                    }
-                });
-                // deal with abort or errors that happened during streaming:
-                if (!loopResult.ok) {
-                    const finishMetadata = {
-                        eventType: "finished",
-                        ...startMetadata,
-                        finishTimestamp: new Date(),
-                        durationInMs: durationMeasurement.durationInMs,
-                    };
-                    if (loopResult.isAborted) {
-                        eventSource.notify({
-                            ...finishMetadata,
-                            eventType: "finished",
-                            result: {
-                                status: "abort",
-                            },
-                        });
-                        responseQueue.error(new AbortError_js_1.AbortError());
-                        return; // error is handled through queue
-                    }
-                    eventSource.notify({
-                        ...finishMetadata,
-                        eventType: "finished",
-                        result: {
-                            status: "error",
-                            error: loopResult.error,
-                        },
-                    });
-                    responseQueue.error(loopResult.error);
-                    return; // error is handled through queue
-                }
-                onDone?.();
-                const finishMetadata = {
-                    eventType: "finished",
-                    ...startMetadata,
-                    finishTimestamp: new Date(),
-                    durationInMs: durationMeasurement.durationInMs,
-                };
-                eventSource.notify({
-                    ...finishMetadata,
-                    result: {
-                        status: "success",
-                    },
-                });
-            }
-            finally {
-                // always close the queue when done, no matter where a potential error happened:
-                responseQueue.close();
-            }
-        })();
-        return {
-            stream: responseQueue,
-        };
-    });
-    if (!result.ok) {
-        const finishMetadata = {
-            eventType: "finished",
-            ...startMetadata,
-            finishTimestamp: new Date(),
-            durationInMs: durationMeasurement.durationInMs,
-        };
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                eventType: "finished",
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError_js_1.AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            eventType: "finished",
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    return {
-        value: result.value.stream,
-        metadata: startMetadata,
-    };
-}
-exports.executeStreamCall = executeStreamCall;

package/model-function/executeStreamCall.d.ts

@@ -1,20 +0,0 @@
-import { FunctionCallOptions, FunctionOptions } from "../core/FunctionOptions.js";
-import { Delta } from "./Delta.js";
-import { Model, ModelSettings } from "./Model.js";
-import { ModelCallStartedEvent } from "./ModelCallEvent.js";
-import { ModelCallMetadata } from "./ModelCallMetadata.js";
-export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, startStream, processDelta, processFinished, onDone, }: {
-    model: MODEL;
-    options?: FunctionOptions;
-    input: unknown;
-    functionType: ModelCallStartedEvent["functionType"];
-    startStream: (options: FunctionCallOptions) => PromiseLike<AsyncIterable<Delta<DELTA_VALUE>>>;
-    processDelta: (delta: Delta<DELTA_VALUE> & {
-        type: "delta";
-    }) => VALUE | undefined;
-    processFinished?: () => VALUE | undefined;
-    onDone?: () => void;
-}): Promise<{
-    value: AsyncIterable<VALUE>;
-    metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
-}>;