modelfusion 0.21.0 → 0.22.0

package/composed-function/summarize/SummarizationFunction.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../run/FunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 export type SummarizationFunction = (input: {
     text: string;
 }, options?: FunctionOptions) => PromiseLike<string>;

package/composed-function/summarize/summarizeRecursively.d.ts

@@ -1,4 +1,4 @@
-import { Run } from "../../run/Run.js";
+import { Run } from "../../core/Run.js";
 import { SplitFunction } from "../../text-chunk/split/SplitFunction.js";
 import { SummarizationFunction } from "./SummarizationFunction.js";
 export declare function summarizeRecursively({ summarize, split, join, text, }: {

package/composed-function/summarize/summarizeRecursivelyWithTextGenerationAndTokenSplitting.d.ts

@@ -1,6 +1,6 @@
 import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { Run } from "../../run/Run.js";
+import { Run } from "../../core/Run.js";
 /**
  * Recursively summarizes a text using a text generation model, e.g. for summarization or text extraction.
  * It automatically splits the text into optimal chunks that are small enough to be processed by the model,

package/{run → core}/DefaultRun.cjs

@@ -5,7 +5,7 @@ const nanoid_1 = require("nanoid");
 const calculateCost_js_1 = require("../cost/calculateCost.cjs");
 const SuccessfulModelCall_js_1 = require("../model-function/SuccessfulModelCall.cjs");
 class DefaultRun {
-    constructor({ runId = (0, nanoid_1.nanoid)(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
+    constructor({ runId = `run-${(0, nanoid_1.nanoid)()}`, sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
         Object.defineProperty(this, "runId", {
             enumerable: true,
             configurable: true,

package/{run → core}/DefaultRun.js

@@ -2,7 +2,7 @@ import { nanoid as createId } from "nanoid";
 import { calculateCost } from "../cost/calculateCost.js";
 import { extractSuccessfulModelCalls, } from "../model-function/SuccessfulModelCall.js";
 export class DefaultRun {
-    constructor({ runId = createId(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
+    constructor({ runId = `run-${createId()}`, sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
         Object.defineProperty(this, "runId", {
             enumerable: true,
             configurable: true,

package/{run → core}/FunctionEvent.d.ts

@@ -1,6 +1,6 @@
 import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
 import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
-export type BaseFunctionEvent = {
+export interface BaseFunctionEvent {
     /**
      * Unique identifier for the function call.
      */
@@ -36,16 +36,40 @@ export type BaseFunctionEvent = {
      * Type of the function. Defined in the subclasses.
      */
     functionType: string;
-};
-export type BaseFunctionStartedEvent = BaseFunctionEvent & {
+}
+export interface BaseFunctionStartedEvent extends BaseFunctionEvent {
     eventType: "started";
+    /**
+     * Timestamp when the function call started.
+     */
     startTimestamp: Date;
+}
+export type BaseFunctionFinishedEventResult = {
+    status: "success";
+    output: unknown;
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
 };
-export type BaseFunctionFinishedEvent = BaseFunctionEvent & {
+export interface BaseFunctionFinishedEvent extends BaseFunctionEvent {
     eventType: "finished";
-    status: "success" | "error" | "abort";
+    /**
+     * Timestamp when the function call started.
+     */
     startTimestamp: Date;
+    /**
+     * Timestamp when the function call finished.
+     */
     finishTimestamp: Date;
+    /**
+     * Duration of the function call in milliseconds.
+     */
     durationInMs: number;
-};
+    /**
+     * Result of the function call.
+     */
+    result: BaseFunctionFinishedEventResult;
+}
 export type FunctionEvent = ModelCallStartedEvent | ExecuteToolStartedEvent | ModelCallFinishedEvent | ExecuteToolFinishedEvent;

package/index.cjs

@@ -15,11 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./composed-function/index.cjs"), exports);
+__exportStar(require("./core/index.cjs"), exports);
 __exportStar(require("./cost/index.cjs"), exports);
 __exportStar(require("./model-function/index.cjs"), exports);
 __exportStar(require("./model-provider/index.cjs"), exports);
 __exportStar(require("./prompt/index.cjs"), exports);
-__exportStar(require("./run/index.cjs"), exports);
 __exportStar(require("./text-chunk/index.cjs"), exports);
 __exportStar(require("./tool/index.cjs"), exports);
 __exportStar(require("./util/index.cjs"), exports);

package/index.d.ts

@@ -1,9 +1,9 @@
 export * from "./composed-function/index.js";
+export * from "./core/index.js";
 export * from "./cost/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./prompt/index.js";
-export * from "./run/index.js";
 export * from "./text-chunk/index.js";
 export * from "./tool/index.js";
 export * from "./util/index.js";

package/index.js

@@ -1,9 +1,9 @@
 export * from "./composed-function/index.js";
+export * from "./core/index.js";
 export * from "./cost/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./prompt/index.js";
-export * from "./run/index.js";
 export * from "./text-chunk/index.js";
 export * from "./tool/index.js";
 export * from "./util/index.js";

package/model-function/Model.d.ts

@@ -1,5 +1,5 @@
 import { ModelInformation } from "./ModelInformation.js";
-import { FunctionObserver } from "../run/FunctionObserver.js";
+import { FunctionObserver } from "../core/FunctionObserver.js";
 export interface ModelSettings {
     /**
      * Observers that are called when the model is used in run functions.

package/model-function/ModelCallEvent.d.ts

@@ -1,4 +1,4 @@
-import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../run/FunctionEvent.js";
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
 import { ModelInformation } from "./ModelInformation.js";
 import { TextEmbeddingFinishedEvent, TextEmbeddingStartedEvent } from "./embed-text/TextEmbeddingEvent.js";
 import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
@@ -7,11 +7,26 @@ import { TextGenerationFinishedEvent, TextGenerationStartedEvent } from "./gener
 import { TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextStreamingEvent.js";
 import { SpeechSynthesisFinishedEvent, SpeechSynthesisStartedEvent } from "./synthesize-speech/SpeechSynthesisEvent.js";
 import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./transcribe-speech/TranscriptionEvent.js";
-export type BaseModelCallStartedEvent = BaseFunctionStartedEvent & {
+export interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
     model: ModelInformation;
+    settings: unknown;
+    input: unknown;
+}
+export type BaseModelCallFinishedEventResult = {
+    status: "success";
+    response: unknown;
+    output: unknown;
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
 };
-export type ModelCallStartedEvent = ImageGenerationStartedEvent | JsonGenerationStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type BaseModelCallFinishedEvent = BaseFunctionFinishedEvent & {
+export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
     model: ModelInformation;
-};
+    settings: unknown;
+    input: unknown;
+    result: BaseModelCallFinishedEventResult;
+}
+export type ModelCallStartedEvent = ImageGenerationStartedEvent | JsonGenerationStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
 export type ModelCallFinishedEvent = ImageGenerationFinishedEvent | JsonGenerationFinishedEvent | SpeechSynthesisFinishedEvent | TextEmbeddingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;

package/model-function/ModelFunctionOptions.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../run/FunctionOptions.js";
+import { FunctionOptions } from "../core/FunctionOptions.js";
 export interface ModelFunctionOptions<SETTINGS> extends FunctionOptions {
     settings?: Partial<SETTINGS>;
 }

package/model-function/SuccessfulModelCall.cjs

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractSuccessfulModelCalls = void 0;
 function extractSuccessfulModelCalls(runFunctionEvents) {
     return runFunctionEvents
-        .filter((event) => "status" in event && event.status === "success")
+        .filter((event) => "result" in event &&
+        "status" in event.result &&
+        event.result.status === "success")
         .map((event) => ({
         model: event.model,
         settings: event.settings,
-        response: event.response,
+        response: event.result.response,
         type: event.functionType,
     }));
 }

package/model-function/SuccessfulModelCall.d.ts

@@ -1,4 +1,4 @@
-import { FunctionEvent } from "../run/FunctionEvent.js";
+import { FunctionEvent } from "../core/FunctionEvent.js";
 import { ModelInformation } from "./ModelInformation.js";
 export type SuccessfulModelCall = {
     type: "image-generation" | "json-generation" | "json-or-text-generation" | "speech-synthesis" | "text-embedding" | "text-generation" | "text-streaming" | "transcription";

package/model-function/SuccessfulModelCall.js

@@ -1,10 +1,12 @@
 export function extractSuccessfulModelCalls(runFunctionEvents) {
     return runFunctionEvents
-        .filter((event) => "status" in event && event.status === "success")
+        .filter((event) => "result" in event &&
+        "status" in event.result &&
+        event.result.status === "success")
         .map((event) => ({
         model: event.model,
         settings: event.settings,
-        response: event.response,
+        response: event.result.response,
         type: event.functionType,
     }));
 }

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

@@ -1,21 +1,21 @@
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.js";
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type TextEmbeddingStartedEvent = BaseModelCallStartedEvent & {
+export interface TextEmbeddingStartedEvent extends BaseModelCallStartedEvent {
     functionType: "text-embedding";
-    settings: unknown;
-    texts: Array<string>;
-};
-export type TextEmbeddingFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "text-embedding";
-    settings: unknown;
-    texts: Array<string>;
-} & ({
+    input: string | Array<string>;
+}
+export type TextEmbeddingFinishedEventResult = {
     status: "success";
     response: unknown;
-    generatedEmbeddings: Array<Vector>;
+    output: Vector | Array<Vector>;
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface TextEmbeddingFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "text-embedding";
+    input: string | Array<string>;
+    result: TextEmbeddingFinishedEventResult;
+}

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

@@ -1,4 +1,4 @@
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.js";
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface TextEmbeddingModelSettings extends ModelSettings {

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

@@ -16,6 +16,8 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function embedTexts(model, texts, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "text-embedding",
+        input: texts,
         model,
         options,
         generateResponse: (options) => {
@@ -34,33 +36,6 @@ function embedTexts(model, texts, options) {
             }
             return embeddings;
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: output,
-        }),
     });
 }
 exports.embedTexts = embedTexts;
@@ -74,43 +49,13 @@ exports.embedTexts = embedTexts;
  * );
  */
 function embedText(model, text, options) {
-    const texts = [text];
     return (0, executeCall_js_1.executeCall)({
+        functionType: "text-embedding",
+        input: text,
         model,
         options,
-        generateResponse: (options) => {
-            return model.generateEmbeddingResponse(texts, options);
-        },
-        extractOutputValue: (result) => {
-            return model.extractEmbeddings(result)[0];
-        },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: [output],
-        }),
+        generateResponse: (options) => model.generateEmbeddingResponse([text], options),
+        extractOutputValue: (result) => model.extractEmbeddings(result)[0],
     });
 }
 exports.embedText = embedText;

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

@@ -1,4 +1,4 @@
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.js";
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "./TextEmbeddingModel.js";

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

@@ -13,6 +13,8 @@ import { executeCall } from "../executeCall.js";
  */
 export function embedTexts(model, texts, options) {
     return executeCall({
+        functionType: "text-embedding",
+        input: texts,
         model,
         options,
         generateResponse: (options) => {
@@ -31,33 +33,6 @@ export function embedTexts(model, texts, options) {
             }
             return embeddings;
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: output,
-        }),
     });
 }
 /**
@@ -70,42 +45,12 @@ export function embedTexts(model, texts, options) {
  * );
  */
 export function embedText(model, text, options) {
-    const texts = [text];
     return executeCall({
+        functionType: "text-embedding",
+        input: text,
         model,
         options,
-        generateResponse: (options) => {
-            return model.generateEmbeddingResponse(texts, options);
-        },
-        extractOutputValue: (result) => {
-            return model.extractEmbeddings(result)[0];
-        },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: [output],
-        }),
+        generateResponse: (options) => model.generateEmbeddingResponse([text], options),
+        extractOutputValue: (result) => model.extractEmbeddings(result)[0],
     });
 }

package/model-function/executeCall.cjs

@@ -2,19 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelFunctionPromise = exports.executeCall = void 0;
 const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../run/FunctionEventSource.cjs");
-const GlobalFunctionObservers_js_1 = require("../run/GlobalFunctionObservers.cjs");
+const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
 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");
-function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     return new ModelFunctionPromise(doExecuteCall({
         model,
         options,
-        getStartEvent,
-        getAbortEvent,
-        getFailureEvent,
-        getSuccessEvent,
+        input,
+        functionType,
         generateResponse,
         extractOutputValue,
     }));
@@ -54,7 +52,7 @@ class ModelFunctionPromise extends Promise {
     }
 }
 exports.ModelFunctionPromise = ModelFunctionPromise;
-async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {
@@ -82,13 +80,16 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
+        functionType,
+        input,
+        settings,
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notify(getStartEvent({
+    eventSource.notify({
         ...startMetadata,
         eventType: "started",
-    }, settings));
+    });
     const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
         functionId: options?.functionId,
         settings,
@@ -102,24 +103,36 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notify(getAbortEvent({
+            eventSource.notify({
                 ...finishMetadata,
-                status: "abort",
-            }, settings));
+                eventType: "finished",
+                result: {
+                    status: "abort",
+                },
+            });
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notify(getFailureEvent({
+        eventSource.notify({
             ...finishMetadata,
-            status: "error",
-        }, settings, result.error));
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notify(getSuccessEvent({
+    eventSource.notify({
         ...finishMetadata,
-        status: "success",
-    }, settings, response, output));
+        eventType: "finished",
+        result: {
+            status: "success",
+            response,
+            output,
+        },
+    });
     return {
         output,
         response,

package/model-function/executeCall.d.ts

@@ -1,5 +1,5 @@
 import { Model, ModelSettings } from "./Model.js";
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent, ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelCallStartedEvent } from "./ModelCallEvent.js";
 import { ModelFunctionOptions } from "./ModelFunctionOptions.js";
 export type CallMetadata<MODEL extends Model<unknown>> = {
     callId: string;
@@ -12,19 +12,11 @@ export type CallMetadata<MODEL extends Model<unknown>> = {
     finishTimestamp: Date;
     durationInMs: number;
 };
-export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }: {
+export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, input, functionType, generateResponse, extractOutputValue, }: {
     model: MODEL;
     options?: ModelFunctionOptions<SETTINGS>;
-    getStartEvent: (metadata: Omit<BaseModelCallStartedEvent, "functionType">, settings: SETTINGS) => ModelCallStartedEvent;
-    getAbortEvent: (metadata: Omit<BaseModelCallFinishedEvent & {
-        status: "abort";
-    }, "functionType">, settings: SETTINGS) => ModelCallFinishedEvent;
-    getFailureEvent: (metadata: Omit<BaseModelCallFinishedEvent & {
-        status: "error";
-    }, "functionType">, settings: SETTINGS, error: unknown) => ModelCallFinishedEvent;
-    getSuccessEvent: (metadata: Omit<BaseModelCallFinishedEvent & {
-        status: "success";
-    }, "functionType">, settings: SETTINGS, response: RESPONSE, output: OUTPUT) => ModelCallFinishedEvent;
+    input: unknown;
+    functionType: ModelCallStartedEvent["functionType"];
     generateResponse: (options: ModelFunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
     extractOutputValue: (response: RESPONSE) => OUTPUT;
 }): ModelFunctionPromise<MODEL, OUTPUT, RESPONSE>;