modelfusion 0.34.0 → 0.35.1

package/model-function/generate-structure/fixJson.test.js

@@ -0,0 +1,184 @@
+import { expect, test, describe } from "vitest";
+import { fixJson } from "./fixJson";
+describe("fixJson", () => {
+    test("should handle empty input", () => {
+        expect(fixJson("")).toBe("");
+    });
+    describe("literals", () => {
+        test("should handle incomplete null", () => {
+            expect(fixJson("nul")).toBe("null");
+        });
+        test("should handle incomplete true", () => {
+            expect(fixJson("t")).toBe("true");
+        });
+        test("should handle incomplete false", () => {
+            expect(fixJson("fals")).toBe("false");
+        });
+    });
+    describe("number", () => {
+        test("should handle incomplete numbers", () => {
+            expect(fixJson("12.")).toBe("12");
+        });
+        test("should handle numbers with dot", () => {
+            expect(fixJson("12.2")).toBe("12.2");
+        });
+        test("should handle negative numbers", () => {
+            expect(fixJson("-12")).toBe("-12");
+        });
+        test("should handle incomplete negative numbers", () => {
+            expect(fixJson("-")).toBe("");
+        });
+        test("should handle e-notation numbers", () => {
+            expect(fixJson("2.5e")).toBe("2.5");
+            expect(fixJson("2.5e-")).toBe("2.5");
+            expect(fixJson("2.5e3")).toBe("2.5e3");
+            expect(fixJson("-2.5e3")).toBe("-2.5e3");
+        });
+        test("should handle uppercase e-notation numbers", () => {
+            expect(fixJson("2.5E")).toBe("2.5");
+            expect(fixJson("2.5E-")).toBe("2.5");
+            expect(fixJson("2.5E3")).toBe("2.5E3");
+            expect(fixJson("-2.5E3")).toBe("-2.5E3");
+        });
+        test("should handle incomplete numbers", () => {
+            expect(fixJson("12.e")).toBe("12");
+            expect(fixJson("12.34e")).toBe("12.34");
+            expect(fixJson("5e")).toBe("5");
+        });
+    });
+    describe("string", () => {
+        test("should handle incomplete strings", () => {
+            expect(fixJson('"abc')).toBe('"abc"');
+        });
+        test("should handle escape sequences", () => {
+            expect(fixJson('"value with \\"quoted\\" text and \\\\ escape')).toBe('"value with \\"quoted\\" text and \\\\ escape"');
+        });
+        test("should handle incomplete escape sequences", () => {
+            expect(fixJson('"value with \\')).toBe('"value with "');
+        });
+        test("should handle unicode characters", () => {
+            expect(fixJson('"value with unicode \u003C"')).toBe('"value with unicode \u003C"');
+        });
+    });
+    describe("array", () => {
+        test("should handle incomplete array", () => {
+            expect(fixJson("[")).toBe("[]");
+        });
+        test("should handle closing bracket after number in array", () => {
+            expect(fixJson("[[1], [2")).toBe("[[1], [2]]");
+        });
+        test("should handle closing bracket after string in array", () => {
+            expect(fixJson(`[["1"], ["2`)).toBe(`[["1"], ["2"]]`);
+        });
+        test("should handle closing bracket after literal in array", () => {
+            expect(fixJson("[[false], [nu")).toBe("[[false], [null]]");
+        });
+        test("should handle closing bracket after array in array", () => {
+            expect(fixJson("[[[]], [[]")).toBe("[[[]], [[]]]");
+        });
+        test("should handle closing bracket after object in array", () => {
+            expect(fixJson("[[{}], [{")).toBe("[[{}], [{}]]");
+        });
+        test("should handle trailing comma", () => {
+            expect(fixJson("[1, ")).toBe("[1]");
+        });
+        test("should handle closing array", () => {
+            expect(fixJson("[[], 123")).toBe("[[], 123]");
+        });
+    });
+    describe("object", () => {
+        test("should handle keys without values", () => {
+            expect(fixJson('{"key":')).toBe("{}");
+        });
+        test("should handle closing brace after number in object", () => {
+            expect(fixJson('{"a": {"b": 1}, "c": {"d": 2')).toBe('{"a": {"b": 1}, "c": {"d": 2}}');
+        });
+        test("should handle closing brace after string in object", () => {
+            expect(fixJson('{"a": {"b": "1"}, "c": {"d": 2')).toBe('{"a": {"b": "1"}, "c": {"d": 2}}');
+        });
+        test("should handle closing brace after literal in object", () => {
+            expect(fixJson('{"a": {"b": false}, "c": {"d": 2')).toBe('{"a": {"b": false}, "c": {"d": 2}}');
+        });
+        test("should handle closing brace after array in object", () => {
+            expect(fixJson('{"a": {"b": []}, "c": {"d": 2')).toBe('{"a": {"b": []}, "c": {"d": 2}}');
+        });
+        test("should handle closing brace after object in object", () => {
+            expect(fixJson('{"a": {"b": {}}, "c": {"d": 2')).toBe('{"a": {"b": {}}, "c": {"d": 2}}');
+        });
+        test("should handle partial keys (first key)", () => {
+            expect(fixJson('{"ke')).toBe("{}");
+        });
+        test("should handle partial keys (second key)", () => {
+            expect(fixJson('{"k1": 1, "k2')).toBe('{"k1": 1}');
+        });
+        test("should handle partial keys with colon (second key)", () => {
+            expect(fixJson('{"k1": 1, "k2":')).toBe('{"k1": 1}');
+        });
+        test("should handle trailing whitespaces", () => {
+            expect(fixJson('{"key": "value"  ')).toBe('{"key": "value"}');
+        });
+    });
+    describe("nesting", () => {
+        test("should handle nested arrays with numbers", () => {
+            expect(fixJson("[1, [2, 3, [")).toBe("[1, [2, 3, []]]");
+        });
+        test("should handle nested arrays with literals", () => {
+            expect(fixJson("[false, [true, [")).toBe("[false, [true, []]]");
+        });
+        test("should handle nested objects", () => {
+            expect(fixJson('{"key": {"subKey":')).toBe('{"key": {}}');
+        });
+        test("should handle nested objects with numbers", () => {
+            expect(fixJson('{"key": 123, "key2": {"subKey":')).toBe('{"key": 123, "key2": {}}');
+        });
+        test("should handle nested objects with literals", () => {
+            expect(fixJson('{"key": null, "key2": {"subKey":')).toBe('{"key": null, "key2": {}}');
+        });
+        test("should handle arrays within objects", () => {
+            expect(fixJson('{"key": [1, 2, {')).toBe('{"key": [1, 2, {}]}');
+        });
+        test("should handle objects within arrays", () => {
+            expect(fixJson('[1, 2, {"key": "value",')).toBe('[1, 2, {"key": "value"}]');
+        });
+        test("should handle nested arrays and objects", () => {
+            expect(fixJson('{"a": {"b": ["c", {"d": "e",')).toBe('{"a": {"b": ["c", {"d": "e"}]}}');
+        });
+        test("should handle deeply nested structures", () => {
+            expect(fixJson('{"a": {"b": {"c": {"d":')).toBe('{"a": {"b": {"c": {}}}}');
+        });
+        test("should handle potential nested arrays or objects", () => {
+            expect(fixJson('{"a": 1, "b": [')).toBe('{"a": 1, "b": []}');
+            expect(fixJson('{"a": 1, "b": {')).toBe('{"a": 1, "b": {}}');
+            expect(fixJson('{"a": 1, "b": "')).toBe('{"a": 1, "b": ""}');
+        });
+    });
+    describe("regression", () => {
+        test("should handle complex nesting 1", () => {
+            expect(fixJson([
+                "{",
+                '  "a": [',
+                "    {",
+                '      "a1": "v1",',
+                '      "a2": "v2",',
+                `      "a3": "v3"`,
+                "    }",
+                "  ],",
+                '  "b": [',
+                "    {",
+                '      "b1": "n',
+            ].join("\n"))).toBe([
+                "{",
+                '  "a": [',
+                "    {",
+                '      "a1": "v1",',
+                '      "a2": "v2",',
+                `      "a3": "v3"`,
+                "    }",
+                "  ],",
+                '  "b": [',
+                "    {",
+                '      "b1": "n"}]}',
+            ].join("\n"));
+        });
+    });
+});

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

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStructure = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
 const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
-function generateStructure(model, structureDefinition, prompt, options) {
+function generateStructure(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+model, structureDefinition, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)

package/model-function/generate-structure/generateStructure.d.ts

@@ -2,4 +2,4 @@ import { StructureDefinition } from "../../core/structure/StructureDefinition.js
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { StructureGenerationModel, StructureGenerationModelSettings } from "./StructureGenerationModel.js";
-export declare function generateStructure<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, RESPONSE, SETTINGS>, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT | ((structureDefinition: StructureDefinition<NAME, STRUCTURE>) => PROMPT), options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<STRUCTURE, RESPONSE>;
+export declare function generateStructure<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT | ((structureDefinition: StructureDefinition<NAME, STRUCTURE>) => PROMPT), options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<STRUCTURE, RESPONSE>;

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

@@ -1,6 +1,8 @@
 import { executeCall } from "../executeCall.js";
 import { StructureValidationError } from "./StructureValidationError.js";
-export function generateStructure(model, structureDefinition, prompt, options) {
+export function generateStructure(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+model, structureDefinition, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)

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

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePartialJson = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const fixJson_js_1 = require("./fixJson.cjs");
+function parsePartialJson(jsonText) {
+    if (jsonText == null) {
+        return undefined;
+    }
+    try {
+        // first attempt a regular JSON parse:
+        return secure_json_parse_1.default.parse(jsonText);
+    }
+    catch (ignored) {
+        try {
+            // then try to fix the partial JSON and parse it:
+            const fixedJsonText = (0, fixJson_js_1.fixJson)(jsonText);
+            return secure_json_parse_1.default.parse(fixedJsonText);
+        }
+        catch (ignored) {
+            // ignored
+        }
+    }
+    return undefined;
+}
+exports.parsePartialJson = parsePartialJson;

package/model-function/generate-structure/parsePartialJson.d.ts

@@ -0,0 +1 @@
+export declare function parsePartialJson(jsonText: string | undefined): unknown | undefined;

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

@@ -0,0 +1,22 @@
+import SecureJSON from "secure-json-parse";
+import { fixJson } from "./fixJson.js";
+export function parsePartialJson(jsonText) {
+    if (jsonText == null) {
+        return undefined;
+    }
+    try {
+        // first attempt a regular JSON parse:
+        return SecureJSON.parse(jsonText);
+    }
+    catch (ignored) {
+        try {
+            // then try to fix the partial JSON and parse it:
+            const fixedJsonText = fixJson(jsonText);
+            return SecureJSON.parse(fixedJsonText);
+        }
+        catch (ignored) {
+            // ignored
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamStructure = void 0;
+const deep_equal_1 = __importDefault(require("deep-equal"));
+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 DurationMeasurement_js_1 = require("../../util/DurationMeasurement.cjs");
+const runSafe_js_1 = require("../../util/runSafe.cjs");
+const AsyncIterableResultPromise_js_1 = require("../AsyncIterableResultPromise.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) {
+    if (options?.settings != null) {
+        model = model.withSettings(options.settings);
+        options = {
+            functionId: options.functionId,
+            observers: options.observers,
+            run: options.run,
+        };
+    }
+    const run = 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 = {
+        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.generateStructureStreamResponse(structureDefinition, prompt, {
+            functionId: options?.functionId,
+            settings,
+            run,
+        });
+        return (async function* () {
+            function reportError(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,
+                        },
+                    });
+            }
+            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 = model.extractPartialStructure(latestFullDelta);
+                    // only send a new part into the stream when the partial structure has changed:
+                    if (!(0, deep_equal_1.default)(lastStructure, latestStructure, {
+                        strict: true,
+                    })) {
+                        lastFullDelta = latestFullDelta;
+                        lastStructure = latestStructure;
+                        yield {
+                            isComplete: false,
+                            value: lastStructure,
+                        };
+                    }
+                }
+            }
+            // process the final result (full type validation):
+            const parseResult = structureDefinition.schema.validate(lastStructure);
+            if (!parseResult.success) {
+                reportError(parseResult.error);
+                throw parseResult.error;
+            }
+            yield {
+                isComplete: true,
+                value: parseResult.value,
+            };
+            const finishMetadata = {
+                eventType: "finished",
+                ...startMetadata,
+                finishTimestamp: new Date(),
+                durationInMs: durationMeasurement.durationInMs,
+            };
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "success",
+                    response: lastFullDelta,
+                    output: 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.output,
+        metadata: startMetadata,
+    };
+}

package/model-function/generate-structure/streamStructure.d.ts

@@ -0,0 +1,16 @@
+import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
+import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
+import { DeltaEvent } from "../DeltaEvent.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { StructureGenerationModel, StructureGenerationModelSettings } from "./StructureGenerationModel.js";
+export type StructureStreamPart<STRUCTURE> = {
+    isComplete: false;
+    value: unknown;
+} | {
+    isComplete: true;
+    value: STRUCTURE;
+};
+export declare function streamStructure<STRUCTURE, PROMPT, FULL_DELTA, NAME extends string, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS> & {
+    generateStructureStreamResponse: (structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
+    extractPartialStructure: (fullDelta: FULL_DELTA) => unknown | undefined;
+}, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): AsyncIterableResultPromise<StructureStreamPart<STRUCTURE>>;

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

@@ -0,0 +1,160 @@
+import deepEqual from "deep-equal";
+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 { startDurationMeasurement } from "../../util/DurationMeasurement.js";
+import { runSafe } from "../../util/runSafe.js";
+import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
+export function streamStructure(model, structureDefinition, prompt, options) {
+    return new AsyncIterableResultPromise(doStreamStructure(model, structureDefinition, prompt, options));
+}
+async function doStreamStructure(model, structureDefinition, prompt, options) {
+    if (options?.settings != null) {
+        model = model.withSettings(options.settings);
+        options = {
+            functionId: options.functionId,
+            observers: options.observers,
+            run: options.run,
+        };
+    }
+    const run = 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 = {
+        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.generateStructureStreamResponse(structureDefinition, prompt, {
+            functionId: options?.functionId,
+            settings,
+            run,
+        });
+        return (async function* () {
+            function reportError(error) {
+                const finishMetadata = {
+                    eventType: "finished",
+                    ...startMetadata,
+                    finishTimestamp: new Date(),
+                    durationInMs: durationMeasurement.durationInMs,
+                };
+                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 = model.extractPartialStructure(latestFullDelta);
+                    // only send a new part into the stream when the partial structure has changed:
+                    if (!deepEqual(lastStructure, latestStructure, {
+                        strict: true,
+                    })) {
+                        lastFullDelta = latestFullDelta;
+                        lastStructure = latestStructure;
+                        yield {
+                            isComplete: false,
+                            value: lastStructure,
+                        };
+                    }
+                }
+            }
+            // process the final result (full type validation):
+            const parseResult = structureDefinition.schema.validate(lastStructure);
+            if (!parseResult.success) {
+                reportError(parseResult.error);
+                throw parseResult.error;
+            }
+            yield {
+                isComplete: true,
+                value: parseResult.value,
+            };
+            const finishMetadata = {
+                eventType: "finished",
+                ...startMetadata,
+                finishTimestamp: new Date(),
+                durationInMs: durationMeasurement.durationInMs,
+            };
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "success",
+                    response: lastFullDelta,
+                    output: 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.output,
+        metadata: startMetadata,
+    };
+}

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

@@ -1,9 +1,9 @@
 import { PromptFormat } from "../../prompt/PromptFormat.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { DeltaEvent } from "../DeltaEvent.js";
 import { Model, ModelSettings } from "../Model.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
-import { DeltaEvent } from "./DeltaEvent.js";
 export interface TextGenerationModelSettings extends ModelSettings {
     /**
      * Maximum number of tokens to generate.
@@ -33,11 +33,11 @@ export interface TextGenerationModel<PROMPT, RESPONSE, FULL_DELTA, SETTINGS exte
     /**
      * Optional. Implement for streaming support.
      */
-    readonly generateDeltaStreamResponse: ((prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>) | undefined;
+    readonly generateDeltaStreamResponse?: (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
     /**
      * Optional. Implement for streaming support.
      */
-    readonly extractTextDelta: ((fullDelta: FULL_DELTA) => string | undefined) | undefined;
+    readonly extractTextDelta?: (fullDelta: FULL_DELTA) => string | undefined;
     extractUsage?(response: RESPONSE): {
         promptTokens: number;
         completionTokens: number;