modelfusion 0.0.44

package/model-function/ModelCallEventSource.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelCallEventSource = void 0;
+class ModelCallEventSource {
+    constructor({ observers, errorHandler, }) {
+        Object.defineProperty(this, "observers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "errorHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.observers = observers;
+        this.errorHandler = errorHandler ?? ((error) => console.error(error));
+    }
+    notifyModelCallStarted(event) {
+        for (const observer of this.observers) {
+            try {
+                observer.onModelCallStarted?.(event);
+            }
+            catch (error) {
+                this.errorHandler(error);
+            }
+        }
+    }
+    notifyModelCallFinished(event) {
+        for (const observer of this.observers) {
+            try {
+                observer.onModelCallFinished?.(event);
+            }
+            catch (error) {
+                this.errorHandler(error);
+            }
+        }
+    }
+}
+exports.ModelCallEventSource = ModelCallEventSource;

package/model-function/ModelCallEventSource.d.ts

@@ -0,0 +1,13 @@
+import { ErrorHandler } from "../util/ErrorHandler.js";
+import { ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelCallObserver } from "./ModelCallObserver.js";
+export declare class ModelCallEventSource {
+    readonly observers: ModelCallObserver[];
+    readonly errorHandler: ErrorHandler;
+    constructor({ observers, errorHandler, }: {
+        observers: ModelCallObserver[];
+        errorHandler?: ErrorHandler;
+    });
+    notifyModelCallStarted(event: ModelCallStartedEvent): void;
+    notifyModelCallFinished(event: ModelCallFinishedEvent): void;
+}

package/model-function/ModelCallEventSource.js

@@ -0,0 +1,38 @@
+export class ModelCallEventSource {
+    constructor({ observers, errorHandler, }) {
+        Object.defineProperty(this, "observers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "errorHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.observers = observers;
+        this.errorHandler = errorHandler ?? ((error) => console.error(error));
+    }
+    notifyModelCallStarted(event) {
+        for (const observer of this.observers) {
+            try {
+                observer.onModelCallStarted?.(event);
+            }
+            catch (error) {
+                this.errorHandler(error);
+            }
+        }
+    }
+    notifyModelCallFinished(event) {
+        for (const observer of this.observers) {
+            try {
+                observer.onModelCallFinished?.(event);
+            }
+            catch (error) {
+                this.errorHandler(error);
+            }
+        }
+    }
+}

package/model-function/ModelCallObserver.cjs

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

package/model-function/ModelCallObserver.d.ts

@@ -0,0 +1,5 @@
+import { ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
+export type ModelCallObserver = {
+    onModelCallStarted?: (event: ModelCallStartedEvent) => void;
+    onModelCallFinished?: (event: ModelCallFinishedEvent) => void;
+};

package/model-function/ModelCallObserver.js

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

package/model-function/ModelInformation.cjs

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

package/model-function/ModelInformation.d.ts

@@ -0,0 +1,4 @@
+export type ModelInformation = {
+    provider: string;
+    modelName: string | null;
+};

package/model-function/ModelInformation.js

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

package/model-function/SuccessfulModelCall.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSuccessfulModelCalls = void 0;
+function extractSuccessfulModelCalls(modelCallEvents) {
+    return modelCallEvents
+        .filter((event) => "status" in event && event.status === "success")
+        .map((event) => ({
+        model: event.metadata.model,
+        settings: event.settings,
+        response: event.response,
+        type: eventTypeToCostType[event.type],
+    }));
+}
+exports.extractSuccessfulModelCalls = extractSuccessfulModelCalls;
+const eventTypeToCostType = {
+    "image-generation-finished": "image-generation",
+    "json-generation-finished": "json-generation",
+    "text-embedding-finished": "text-embedding",
+    "text-generation-finished": "text-generation",
+    "text-streaming-finished": "text-streaming",
+    "transcription-finished": "transcription",
+};

package/model-function/SuccessfulModelCall.d.ts

@@ -0,0 +1,9 @@
+import { ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelInformation } from "./ModelInformation.js";
+export type SuccessfulModelCall = {
+    type: "image-generation" | "json-generation" | "text-embedding" | "text-generation" | "text-streaming" | "transcription";
+    model: ModelInformation;
+    settings: unknown;
+    response: unknown;
+};
+export declare function extractSuccessfulModelCalls(modelCallEvents: (ModelCallFinishedEvent | ModelCallStartedEvent)[]): SuccessfulModelCall[];

package/model-function/SuccessfulModelCall.js

@@ -0,0 +1,18 @@
+export function extractSuccessfulModelCalls(modelCallEvents) {
+    return modelCallEvents
+        .filter((event) => "status" in event && event.status === "success")
+        .map((event) => ({
+        model: event.metadata.model,
+        settings: event.settings,
+        response: event.response,
+        type: eventTypeToCostType[event.type],
+    }));
+}
+const eventTypeToCostType = {
+    "image-generation-finished": "image-generation",
+    "json-generation-finished": "json-generation",
+    "text-embedding-finished": "text-embedding",
+    "text-generation-finished": "text-generation",
+    "text-streaming-finished": "text-streaming",
+    "transcription-finished": "transcription",
+};

package/model-function/embed-text/TextEmbeddingEvent.cjs

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

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

@@ -0,0 +1,23 @@
+import { Vector } from "../../run/Vector.js";
+import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
+export type TextEmbeddingStartedEvent = {
+    type: "text-embedding-started";
+    metadata: ModelCallStartedEventMetadata;
+    settings: unknown;
+    texts: Array<string>;
+};
+export type TextEmbeddingFinishedEvent = {
+    type: "text-embedding-finished";
+    metadata: ModelCallFinishedEventMetadata;
+    settings: unknown;
+    texts: Array<string>;
+} & ({
+    status: "success";
+    response: unknown;
+    generatedEmbeddings: Array<Vector>;
+} | {
+    status: "failure";
+    error: unknown;
+} | {
+    status: "abort";
+});

package/model-function/embed-text/TextEmbeddingEvent.js

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

package/model-function/embed-text/TextEmbeddingModel.cjs

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

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

@@ -0,0 +1,18 @@
+import { Vector } from "../../run/Vector.js";
+import { FunctionOptions } from "../FunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface TextEmbeddingModelSettings extends ModelSettings {
+}
+export interface TextEmbeddingModel<RESPONSE, SETTINGS extends TextEmbeddingModelSettings> extends Model<SETTINGS> {
+    /**
+     * The limit of tokens for a single text.
+     */
+    readonly contextWindowSize: number | undefined;
+    /**
+     * The size of the embedding vector.
+     */
+    readonly embeddingDimensions: number | undefined;
+    readonly maxTextsPerCall: number;
+    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    extractEmbeddings(response: RESPONSE): Vector[];
+}

package/model-function/embed-text/TextEmbeddingModel.js

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

package/model-function/embed-text/embedText.cjs

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embedText = exports.embedTexts = void 0;
+const executeCall_js_1 = require("../executeCall.cjs");
+/**
+ * Generate embeddings for multiple texts.
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new OpenAITextEmbeddingModel(...),
+ *   [
+ *     "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.",
+ *   ]
+ * );
+ */
+async function embedTexts(model, texts, options) {
+    const result = await (0, executeCall_js_1.executeCall)({
+        model,
+        options,
+        generateResponse: (options) => {
+            // split the texts into groups that are small enough to be sent in one call:
+            const maxTextsPerCall = model.maxTextsPerCall;
+            const textGroups = [];
+            for (let i = 0; i < texts.length; i += maxTextsPerCall) {
+                textGroups.push(texts.slice(i, i + maxTextsPerCall));
+            }
+            return Promise.all(textGroups.map((textGroup) => model.generateEmbeddingResponse(textGroup, options)));
+        },
+        extractOutputValue: (result) => {
+            const embeddings = [];
+            for (const response of result) {
+                embeddings.push(...model.extractEmbeddings(response));
+            }
+            return embeddings;
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "text-embedding-started",
+            metadata,
+            settings,
+            texts,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "text-embedding-finished",
+            status: "abort",
+            metadata,
+            settings,
+            texts,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "text-embedding-finished",
+            status: "failure",
+            metadata,
+            settings,
+            error,
+            texts,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "text-embedding-finished",
+            status: "success",
+            metadata,
+            settings,
+            texts,
+            response,
+            generatedEmbeddings: output,
+        }),
+    });
+    return {
+        embeddings: result.output,
+        metadata: result.metadata,
+    };
+}
+exports.embedTexts = embedTexts;
+/**
+ * Generate an embedding for a single text.
+ *
+ * @example
+ * const { embedding } = await embedText(
+ *   new OpenAITextEmbeddingModel(...),
+ *   "At first, Nox didn't know what to do with the pup."
+ * );
+ */
+async function embedText(model, text, options) {
+    const result = await embedTexts(model, [text], options);
+    return {
+        embedding: result.embeddings[0],
+        metadata: result.metadata,
+    };
+}
+exports.embedText = embedText;

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

@@ -0,0 +1,33 @@
+import { Vector } from "../../run/Vector.js";
+import { FunctionOptions } from "../FunctionOptions.js";
+import { CallMetadata } from "../executeCall.js";
+import { TextEmbeddingModel, TextEmbeddingModelSettings } from "./TextEmbeddingModel.js";
+/**
+ * Generate embeddings for multiple texts.
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new OpenAITextEmbeddingModel(...),
+ *   [
+ *     "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.",
+ *   ]
+ * );
+ */
+export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, texts: string[], options?: FunctionOptions<SETTINGS>): Promise<{
+    embeddings: Array<Vector>;
+    metadata: CallMetadata<TextEmbeddingModel<RESPONSE, SETTINGS>>;
+}>;
+/**
+ * Generate an embedding for a single text.
+ *
+ * @example
+ * const { embedding } = await embedText(
+ *   new OpenAITextEmbeddingModel(...),
+ *   "At first, Nox didn't know what to do with the pup."
+ * );
+ */
+export declare function embedText<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, text: string, options?: FunctionOptions<SETTINGS>): Promise<{
+    embedding: Vector;
+    metadata: CallMetadata<TextEmbeddingModel<RESPONSE, SETTINGS>>;
+}>;

package/model-function/embed-text/embedText.js

@@ -0,0 +1,85 @@
+import { executeCall } from "../executeCall.js";
+/**
+ * Generate embeddings for multiple texts.
+ *
+ * @example
+ * const { embeddings } = await embedTexts(
+ *   new OpenAITextEmbeddingModel(...),
+ *   [
+ *     "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.",
+ *   ]
+ * );
+ */
+export async function embedTexts(model, texts, options) {
+    const result = await executeCall({
+        model,
+        options,
+        generateResponse: (options) => {
+            // split the texts into groups that are small enough to be sent in one call:
+            const maxTextsPerCall = model.maxTextsPerCall;
+            const textGroups = [];
+            for (let i = 0; i < texts.length; i += maxTextsPerCall) {
+                textGroups.push(texts.slice(i, i + maxTextsPerCall));
+            }
+            return Promise.all(textGroups.map((textGroup) => model.generateEmbeddingResponse(textGroup, options)));
+        },
+        extractOutputValue: (result) => {
+            const embeddings = [];
+            for (const response of result) {
+                embeddings.push(...model.extractEmbeddings(response));
+            }
+            return embeddings;
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "text-embedding-started",
+            metadata,
+            settings,
+            texts,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "text-embedding-finished",
+            status: "abort",
+            metadata,
+            settings,
+            texts,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "text-embedding-finished",
+            status: "failure",
+            metadata,
+            settings,
+            error,
+            texts,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "text-embedding-finished",
+            status: "success",
+            metadata,
+            settings,
+            texts,
+            response,
+            generatedEmbeddings: output,
+        }),
+    });
+    return {
+        embeddings: result.output,
+        metadata: result.metadata,
+    };
+}
+/**
+ * Generate an embedding for a single text.
+ *
+ * @example
+ * const { embedding } = await embedText(
+ *   new OpenAITextEmbeddingModel(...),
+ *   "At first, Nox didn't know what to do with the pup."
+ * );
+ */
+export async function embedText(model, text, options) {
+    const result = await embedTexts(model, [text], options);
+    return {
+        embedding: result.embeddings[0],
+        metadata: result.metadata,
+    };
+}

package/model-function/executeCall.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCall = void 0;
+const nanoid_1 = require("nanoid");
+const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
+const AbortError_js_1 = require("../util/api/AbortError.cjs");
+const runSafe_js_1 = require("../util/runSafe.cjs");
+const ModelCallEventSource_js_1 = require("./ModelCallEventSource.cjs");
+async function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+    if (options?.settings != null) {
+        model = model.withSettings(options.settings);
+        options = {
+            functionId: options.functionId,
+            run: options.run,
+        };
+    }
+    const run = options?.run;
+    const settings = model.settings;
+    const eventSource = new ModelCallEventSource_js_1.ModelCallEventSource({
+        observers: [...(settings.observers ?? []), ...(run?.observers ?? [])],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
+    const startMetadata = {
+        callId: `call-${(0, nanoid_1.nanoid)()}`,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        model: model.modelInformation,
+        startEpochSeconds: durationMeasurement.startEpochSeconds,
+    };
+    eventSource.notifyModelCallStarted(getStartEvent(startMetadata, settings));
+    const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
+        functionId: options?.functionId,
+        settings,
+        run,
+    }));
+    const finishMetadata = {
+        ...startMetadata,
+        durationInMs: durationMeasurement.durationInMs,
+    };
+    if (!result.ok) {
+        if (result.isAborted) {
+            eventSource.notifyModelCallFinished(getAbortEvent(finishMetadata, settings));
+            throw new AbortError_js_1.AbortError();
+        }
+        eventSource.notifyModelCallFinished(getFailureEvent(finishMetadata, settings, result.error));
+        throw result.error;
+    }
+    const response = result.output;
+    const output = extractOutputValue(response);
+    eventSource.notifyModelCallFinished(getSuccessEvent(finishMetadata, settings, response, output));
+    return {
+        output,
+        response,
+        metadata: finishMetadata,
+    };
+}
+exports.executeCall = executeCall;

package/model-function/executeCall.d.ts

@@ -0,0 +1,27 @@
+import { FunctionOptions } from "./FunctionOptions.js";
+import { Model, ModelSettings } from "./Model.js";
+import { ModelCallFinishedEvent, ModelCallFinishedEventMetadata, ModelCallStartedEvent, ModelCallStartedEventMetadata } from "./ModelCallEvent.js";
+export type CallMetadata<MODEL extends Model<unknown>> = {
+    callId: string;
+    runId?: string;
+    sessionId?: string;
+    userId?: string;
+    functionId?: string;
+    model: MODEL["modelInformation"];
+    startEpochSeconds: number;
+    durationInMs: number;
+};
+export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }: {
+    model: MODEL;
+    options?: FunctionOptions<SETTINGS>;
+    getStartEvent: (metadata: ModelCallStartedEventMetadata, settings: SETTINGS) => ModelCallStartedEvent;
+    getAbortEvent: (metadata: ModelCallFinishedEventMetadata, settings: SETTINGS) => ModelCallFinishedEvent;
+    getFailureEvent: (metadata: ModelCallFinishedEventMetadata, settings: SETTINGS, error: unknown) => ModelCallFinishedEvent;
+    getSuccessEvent: (metadata: ModelCallFinishedEventMetadata, settings: SETTINGS, response: RESPONSE, output: OUTPUT) => ModelCallFinishedEvent;
+    generateResponse: (options: FunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
+    extractOutputValue: (response: RESPONSE) => OUTPUT;
+}): Promise<{
+    output: OUTPUT;
+    response: RESPONSE;
+    metadata: CallMetadata<MODEL>;
+}>;

package/model-function/executeCall.js

@@ -0,0 +1,56 @@
+import { nanoid as createId } from "nanoid";
+import { startDurationMeasurement } from "../util/DurationMeasurement.js";
+import { AbortError } from "../util/api/AbortError.js";
+import { runSafe } from "../util/runSafe.js";
+import { ModelCallEventSource } from "./ModelCallEventSource.js";
+export async function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+    if (options?.settings != null) {
+        model = model.withSettings(options.settings);
+        options = {
+            functionId: options.functionId,
+            run: options.run,
+        };
+    }
+    const run = options?.run;
+    const settings = model.settings;
+    const eventSource = new ModelCallEventSource({
+        observers: [...(settings.observers ?? []), ...(run?.observers ?? [])],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = startDurationMeasurement();
+    const startMetadata = {
+        callId: `call-${createId()}`,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        model: model.modelInformation,
+        startEpochSeconds: durationMeasurement.startEpochSeconds,
+    };
+    eventSource.notifyModelCallStarted(getStartEvent(startMetadata, settings));
+    const result = await runSafe(() => generateResponse({
+        functionId: options?.functionId,
+        settings,
+        run,
+    }));
+    const finishMetadata = {
+        ...startMetadata,
+        durationInMs: durationMeasurement.durationInMs,
+    };
+    if (!result.ok) {
+        if (result.isAborted) {
+            eventSource.notifyModelCallFinished(getAbortEvent(finishMetadata, settings));
+            throw new AbortError();
+        }
+        eventSource.notifyModelCallFinished(getFailureEvent(finishMetadata, settings, result.error));
+        throw result.error;
+    }
+    const response = result.output;
+    const output = extractOutputValue(response);
+    eventSource.notifyModelCallFinished(getSuccessEvent(finishMetadata, settings, response, output));
+    return {
+        output,
+        response,
+        metadata: finishMetadata,
+    };
+}

package/model-function/generate-image/ImageGenerationEvent.cjs

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

package/model-function/generate-image/ImageGenerationEvent.d.ts

@@ -0,0 +1,22 @@
+import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
+export type ImageGenerationStartedEvent = {
+    type: "image-generation-started";
+    metadata: ModelCallStartedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+};
+export type ImageGenerationFinishedEvent = {
+    type: "image-generation-finished";
+    metadata: ModelCallFinishedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+} & ({
+    status: "success";
+    response: unknown;
+    generatedImage: string;
+} | {
+    status: "failure";
+    error: unknown;
+} | {
+    status: "abort";
+});

package/model-function/generate-image/ImageGenerationEvent.js

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

package/model-function/generate-image/ImageGenerationModel.cjs

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

package/model-function/generate-image/ImageGenerationModel.d.ts

@@ -0,0 +1,8 @@
+import { FunctionOptions } from "../FunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface ImageGenerationModelSettings extends ModelSettings {
+}
+export interface ImageGenerationModel<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings> extends Model<SETTINGS> {
+    generateImageResponse(prompt: PROMPT, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    extractBase64Image(response: RESPONSE): string;
+}

package/model-function/generate-image/ImageGenerationModel.js

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