modelfusion 0.48.0 → 0.49.0

package/model-function/generate-structure/streamStructure.cjs

@@ -1,156 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamStructure = void 0;
-const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../../core/FunctionEventSource.cjs");
-const GlobalFunctionLogging_js_1 = require("../../core/GlobalFunctionLogging.cjs");
-const GlobalFunctionObservers_js_1 = require("../../core/GlobalFunctionObservers.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 isDeepEqualData_js_1 = require("../../util/isDeepEqualData.cjs");
-const runSafe_js_1 = require("../../util/runSafe.cjs");
 const AsyncIterableResultPromise_js_1 = require("../AsyncIterableResultPromise.cjs");
+const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
 function streamStructure(model, structureDefinition, prompt, options) {
-    return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise(doStreamStructure(model, structureDefinition, prompt, options));
-}
-exports.streamStructure = streamStructure;
-async function doStreamStructure(model, structureDefinition, prompt, options) {
-    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, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
-            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
-            ...(settings.observers ?? []),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
-    const startMetadata = {
+    let lastStructure;
+    let lastFullDelta;
+    return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise((0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "structure-streaming",
-        callId: `call-${(0, nanoid_1.nanoid)()}`,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        model: model.modelInformation,
-        settings: model.settingsForEvent,
         input: prompt,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await (0, runSafe_js_1.runSafe)(async () => {
-        const deltaIterable = await model.doStreamStructure(structureDefinition, prompt, {
-            functionId: options?.functionId,
-            logging: options?.logging,
-            observers: options?.observers,
-            run,
-        });
-        return (async function* () {
-            function reportError(error) {
-                const finishMetadata = {
-                    eventType: "finished",
-                    ...startMetadata,
-                    finishTimestamp: new Date(),
-                    durationInMs: durationMeasurement.durationInMs,
+        model,
+        options,
+        startStream: async (options) => model.doStreamStructure(structureDefinition, prompt, options),
+        processDelta: (delta) => {
+            const latestFullDelta = delta.fullDelta;
+            const latestStructure = delta.valueDelta;
+            // only send a new part into the stream when the partial structure has changed:
+            if (!(0, isDeepEqualData_js_1.isDeepEqualData)(lastStructure, latestStructure)) {
+                lastFullDelta = latestFullDelta;
+                lastStructure = latestStructure;
+                return {
+                    isComplete: false,
+                    value: lastStructure,
                 };
-                eventSource.notify(error instanceof AbortError_js_1.AbortError
-                    ? {
-                        ...finishMetadata,
-                        result: {
-                            status: "abort",
-                        },
-                    }
-                    : {
-                        ...finishMetadata,
-                        result: {
-                            status: "error",
-                            error,
-                        },
-                    });
-            }
-            let lastStructure;
-            let lastFullDelta;
-            for await (const event of deltaIterable) {
-                if (event?.type === "error") {
-                    reportError(event.error);
-                    throw event.error;
-                }
-                if (event?.type === "delta") {
-                    const latestFullDelta = event.fullDelta;
-                    const latestStructure = event.valueDelta;
-                    // only send a new part into the stream when the partial structure has changed:
-                    if (!(0, isDeepEqualData_js_1.isDeepEqualData)(lastStructure, latestStructure)) {
-                        lastFullDelta = latestFullDelta;
-                        lastStructure = latestStructure;
-                        yield {
-                            isComplete: false,
-                            value: lastStructure,
-                        };
-                    }
-                }
             }
+            return undefined;
+        },
+        processFinished: () => {
             // process the final result (full type validation):
             const parseResult = structureDefinition.schema.validate(lastStructure);
             if (!parseResult.success) {
                 reportError(parseResult.error);
                 throw parseResult.error;
             }
-            yield {
+            return {
                 isComplete: true,
                 value: parseResult.data,
             };
-            const finishMetadata = {
-                eventType: "finished",
-                ...startMetadata,
-                finishTimestamp: new Date(),
-                durationInMs: durationMeasurement.durationInMs,
-            };
-            eventSource.notify({
-                ...finishMetadata,
-                result: {
-                    status: "success",
-                    response: lastFullDelta,
-                    value: lastStructure,
-                },
-            });
-        })();
-    });
-    if (!result.ok) {
-        const finishMetadata = {
-            eventType: "finished",
-            ...startMetadata,
-            finishTimestamp: new Date(),
-            durationInMs: durationMeasurement.durationInMs,
-        };
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError_js_1.AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    return {
-        output: result.value,
-        metadata: startMetadata,
-    };
+        },
+        getResult: () => ({
+            response: lastFullDelta,
+            value: lastStructure,
+        }),
+    }));
 }
+exports.streamStructure = streamStructure;

package/model-function/generate-structure/streamStructure.js

@@ -1,152 +1,44 @@
-import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../../core/FunctionEventSource.js";
-import { getGlobalFunctionLogging } from "../../core/GlobalFunctionLogging.js";
-import { getGlobalFunctionObservers } from "../../core/GlobalFunctionObservers.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 { isDeepEqualData } from "../../util/isDeepEqualData.js";
-import { runSafe } from "../../util/runSafe.js";
 import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
+import { executeStreamCall } from "../executeStreamCall.js";
 export function streamStructure(model, structureDefinition, prompt, options) {
-    return new AsyncIterableResultPromise(doStreamStructure(model, structureDefinition, prompt, options));
-}
-async function doStreamStructure(model, structureDefinition, prompt, options) {
-    const run = await getRun(options?.run);
-    const settings = model.settings;
-    const eventSource = new FunctionEventSource({
-        observers: [
-            ...getFunctionCallLogger(options?.logging ?? getGlobalFunctionLogging()),
-            ...getGlobalFunctionObservers(),
-            ...(settings.observers ?? []),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = startDurationMeasurement();
-    const startMetadata = {
+    let lastStructure;
+    let lastFullDelta;
+    return new AsyncIterableResultPromise(executeStreamCall({
         functionType: "structure-streaming",
-        callId: `call-${createId()}`,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        model: model.modelInformation,
-        settings: model.settingsForEvent,
         input: prompt,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await runSafe(async () => {
-        const deltaIterable = await model.doStreamStructure(structureDefinition, prompt, {
-            functionId: options?.functionId,
-            logging: options?.logging,
-            observers: options?.observers,
-            run,
-        });
-        return (async function* () {
-            function reportError(error) {
-                const finishMetadata = {
-                    eventType: "finished",
-                    ...startMetadata,
-                    finishTimestamp: new Date(),
-                    durationInMs: durationMeasurement.durationInMs,
+        model,
+        options,
+        startStream: async (options) => model.doStreamStructure(structureDefinition, prompt, options),
+        processDelta: (delta) => {
+            const latestFullDelta = delta.fullDelta;
+            const latestStructure = delta.valueDelta;
+            // only send a new part into the stream when the partial structure has changed:
+            if (!isDeepEqualData(lastStructure, latestStructure)) {
+                lastFullDelta = latestFullDelta;
+                lastStructure = latestStructure;
+                return {
+                    isComplete: false,
+                    value: lastStructure,
                 };
-                eventSource.notify(error instanceof AbortError
-                    ? {
-                        ...finishMetadata,
-                        result: {
-                            status: "abort",
-                        },
-                    }
-                    : {
-                        ...finishMetadata,
-                        result: {
-                            status: "error",
-                            error,
-                        },
-                    });
-            }
-            let lastStructure;
-            let lastFullDelta;
-            for await (const event of deltaIterable) {
-                if (event?.type === "error") {
-                    reportError(event.error);
-                    throw event.error;
-                }
-                if (event?.type === "delta") {
-                    const latestFullDelta = event.fullDelta;
-                    const latestStructure = event.valueDelta;
-                    // only send a new part into the stream when the partial structure has changed:
-                    if (!isDeepEqualData(lastStructure, latestStructure)) {
-                        lastFullDelta = latestFullDelta;
-                        lastStructure = latestStructure;
-                        yield {
-                            isComplete: false,
-                            value: lastStructure,
-                        };
-                    }
-                }
             }
+            return undefined;
+        },
+        processFinished: () => {
             // process the final result (full type validation):
             const parseResult = structureDefinition.schema.validate(lastStructure);
             if (!parseResult.success) {
                 reportError(parseResult.error);
                 throw parseResult.error;
             }
-            yield {
+            return {
                 isComplete: true,
                 value: parseResult.data,
             };
-            const finishMetadata = {
-                eventType: "finished",
-                ...startMetadata,
-                finishTimestamp: new Date(),
-                durationInMs: durationMeasurement.durationInMs,
-            };
-            eventSource.notify({
-                ...finishMetadata,
-                result: {
-                    status: "success",
-                    response: lastFullDelta,
-                    value: lastStructure,
-                },
-            });
-        })();
-    });
-    if (!result.ok) {
-        const finishMetadata = {
-            eventType: "finished",
-            ...startMetadata,
-            finishTimestamp: new Date(),
-            durationInMs: durationMeasurement.durationInMs,
-        };
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    return {
-        output: result.value,
-        metadata: startMetadata,
-    };
+        },
+        getResult: () => ({
+            response: lastFullDelta,
+            value: lastStructure,
+        }),
+    }));
 }

package/model-function/generate-text/TextGenerationEvent.d.ts

@@ -21,3 +21,9 @@ export interface TextGenerationFinishedEvent extends BaseModelCallFinishedEvent
     functionType: "text-generation";
     result: TextGenerationFinishedEventResult;
 }
+export interface TextStreamingStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "text-streaming";
+}
+export interface TextStreamingFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "text-streaming";
+}

package/model-function/generate-text/generateText.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateText = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 /**
  * Generates a text using a prompt.
@@ -9,7 +9,7 @@ const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
  * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
  *
  * @example
- * const model = new OpenAITextGenerationModel(...);
+ * const model = new OpenAICompletionModel(...);
  *
  * const text = await generateText(
  *   model,
@@ -17,7 +17,7 @@ const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
  * );
  */
 function generateText(model, prompt, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "text-generation",
         input: prompt,
         model,

package/model-function/generate-text/generateText.d.ts

@@ -7,7 +7,7 @@ import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerati
  * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
  *
  * @example
- * const model = new OpenAITextGenerationModel(...);
+ * const model = new OpenAICompletionModel(...);
  *
  * const text = await generateText(
  *   model,

package/model-function/generate-text/generateText.js

@@ -1,4 +1,4 @@
-import { executeCall } from "../executeCall.js";
+import { executeStandardCall } from "../executeStandardCall.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 /**
  * Generates a text using a prompt.
@@ -6,7 +6,7 @@ import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
  * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
  *
  * @example
- * const model = new OpenAITextGenerationModel(...);
+ * const model = new OpenAICompletionModel(...);
  *
  * const text = await generateText(
  *   model,
@@ -14,7 +14,7 @@ import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
  * );
  */
 export function generateText(model, prompt, options) {
-    return new ModelFunctionPromise(executeCall({
+    return new ModelFunctionPromise(executeStandardCall({
         functionType: "text-generation",
         input: prompt,
         model,

package/model-function/generate-text/index.cjs

@@ -24,7 +24,6 @@ __exportStar(require("./TextGenerationEvent.cjs"), exports);
 __exportStar(require("./TextGenerationModel.cjs"), exports);
 __exportStar(require("./TextGenerationPromptFormat.cjs"), exports);
 __exportStar(require("./TextPromptFormat.cjs"), exports);
-__exportStar(require("./TextStreamingEvent.cjs"), exports);
 __exportStar(require("./VicunaPromptFormat.cjs"), exports);
 __exportStar(require("./generateText.cjs"), exports);
 __exportStar(require("./streamText.cjs"), exports);

package/model-function/generate-text/index.d.ts

@@ -8,7 +8,6 @@ export * from "./TextGenerationEvent.js";
 export * from "./TextGenerationModel.js";
 export * from "./TextGenerationPromptFormat.js";
 export * from "./TextPromptFormat.js";
-export * from "./TextStreamingEvent.js";
 export * from "./VicunaPromptFormat.js";
 export * from "./generateText.js";
 export * from "./streamText.js";

package/model-function/generate-text/index.js

@@ -8,7 +8,6 @@ export * from "./TextGenerationEvent.js";
 export * from "./TextGenerationModel.js";
 export * from "./TextGenerationPromptFormat.js";
 export * from "./TextPromptFormat.js";
-export * from "./TextStreamingEvent.js";
 export * from "./VicunaPromptFormat.js";
 export * from "./generateText.js";
 export * from "./streamText.js";

package/model-function/generate-text/streamText.cjs

@@ -1,137 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamText = void 0;
-const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../../core/FunctionEventSource.cjs");
-const GlobalFunctionLogging_js_1 = require("../../core/GlobalFunctionLogging.cjs");
-const GlobalFunctionObservers_js_1 = require("../../core/GlobalFunctionObservers.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");
 const AsyncIterableResultPromise_js_1 = require("../AsyncIterableResultPromise.cjs");
+const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
 function streamText(model, prompt, options) {
-    return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise(doStreamText(model, prompt, options));
-}
-exports.streamText = streamText;
-async function doStreamText(model, prompt, options) {
-    const run = await (0, getRun_js_1.getRun)(options?.run);
-    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
-        observers: [
-            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
-            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
-            ...(model.settings.observers ?? []),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
-    const startMetadata = {
+    let accumulatedText = "";
+    let lastFullDelta;
+    return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise((0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "text-streaming",
-        callId: `call-${(0, nanoid_1.nanoid)()}`,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        model: model.modelInformation,
-        settings: model.settingsForEvent,
         input: prompt,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await (0, runSafe_js_1.runSafe)(async () => {
-        const deltaIterable = await model.doStreamText(prompt, {
-            functionId: options?.functionId,
-            logging: options?.logging,
-            observers: options?.observers,
-            run,
-        });
-        return (async function* () {
-            let accumulatedText = "";
-            let lastFullDelta;
-            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") {
-                    lastFullDelta = event.fullDelta;
-                    const textDelta = event.valueDelta;
-                    if (textDelta != null && textDelta.length > 0) {
-                        accumulatedText += textDelta;
-                        yield textDelta;
-                    }
-                }
+        model,
+        options,
+        startStream: async (options) => model.doStreamText(prompt, options),
+        processDelta: (delta) => {
+            lastFullDelta = delta.fullDelta;
+            const textDelta = delta.valueDelta;
+            if (textDelta != null && textDelta.length > 0) {
+                accumulatedText += textDelta;
+                return textDelta;
             }
-            const finishMetadata = {
-                eventType: "finished",
-                ...startMetadata,
-                finishTimestamp: new Date(),
-                durationInMs: durationMeasurement.durationInMs,
-            };
-            eventSource.notify({
-                ...finishMetadata,
-                result: {
-                    status: "success",
-                    response: lastFullDelta,
-                    value: accumulatedText,
-                },
-            });
-        })();
-    });
-    if (!result.ok) {
-        const finishMetadata = {
-            eventType: "finished",
-            ...startMetadata,
-            finishTimestamp: new Date(),
-            durationInMs: durationMeasurement.durationInMs,
-        };
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError_js_1.AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    return {
-        output: result.value,
-        metadata: startMetadata,
-    };
+            return undefined;
+        },
+        getResult: () => ({
+            response: lastFullDelta,
+            value: accumulatedText,
+        }),
+    }));
 }
+exports.streamText = streamText;