modelfusion 0.46.0 → 0.47.1

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

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

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

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStructure = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
+const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
 function generateStructure(model, structureDefinition, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)
         : prompt;
-    return (0, executeCall_js_1.executeCall)({
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
         functionType: "structure-generation",
         input: expandedPrompt,
         model,
@@ -32,6 +33,6 @@ function generateStructure(model, structureDefinition, prompt, options) {
                 usage: result.usage,
             };
         },
-    });
+    }));
 }
 exports.generateStructure = generateStructure;

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

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

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

@@ -1,11 +1,12 @@
 import { executeCall } from "../executeCall.js";
+import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { StructureValidationError } from "./StructureValidationError.js";
 export function generateStructure(model, structureDefinition, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)
         : prompt;
-    return executeCall({
+    return new ModelFunctionPromise(executeCall({
         functionType: "structure-generation",
         input: expandedPrompt,
         model,
@@ -29,5 +30,5 @@ export function generateStructure(model, structureDefinition, prompt, options) {
                 usage: result.usage,
             };
         },
-    });
+    }));
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStructureOrText = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
+const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 const NoSuchStructureError_js_1 = require("./NoSuchStructureError.cjs");
 const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
 function generateStructureOrText(model, structureDefinitions, prompt, options) {
@@ -9,7 +10,7 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinitions)
         : prompt;
-    return (0, executeCall_js_1.executeCall)({
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
         functionType: "structure-or-text-generation",
         input: expandedPrompt,
         model,
@@ -48,6 +49,6 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
                 usage: result.usage,
             };
         },
-    });
+    }));
 }
 exports.generateStructureOrText = generateStructureOrText;

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

@@ -1,6 +1,6 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
-import { ModelFunctionPromise } from "../executeCall.js";
+import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { StructureOrTextGenerationModel, StructureOrTextGenerationModelSettings } from "./StructureOrTextGenerationModel.js";
 type StructureDefinitionArray<T extends StructureDefinition<any, any>[]> = T;
 type ToStructureDefinitionMap<T extends StructureDefinitionArray<StructureDefinition<any, any>[]>> = {

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

@@ -1,4 +1,5 @@
 import { executeCall } from "../executeCall.js";
+import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { NoSuchStructureError } from "./NoSuchStructureError.js";
 import { StructureValidationError } from "./StructureValidationError.js";
 export function generateStructureOrText(model, structureDefinitions, prompt, options) {
@@ -6,7 +7,7 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinitions)
         : prompt;
-    return executeCall({
+    return new ModelFunctionPromise(executeCall({
         functionType: "structure-or-text-generation",
         input: expandedPrompt,
         model,
@@ -45,5 +46,5 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
                 usage: result.usage,
             };
         },
-    });
+    }));
 }

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

@@ -1,10 +1,6 @@
 "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");
@@ -13,6 +9,7 @@ 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");
 function streamStructure(model, structureDefinition, prompt, options) {
@@ -91,9 +88,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
                     const latestFullDelta = event.fullDelta;
                     const latestStructure = event.valueDelta;
                     // only send a new part into the stream when the partial structure has changed:
-                    if (!(0, deep_equal_1.default)(lastStructure, latestStructure, {
-                        strict: true,
-                    })) {
+                    if (!(0, isDeepEqualData_js_1.isDeepEqualData)(lastStructure, latestStructure)) {
                         lastFullDelta = latestFullDelta;
                         lastStructure = latestStructure;
                         yield {

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

@@ -1,4 +1,3 @@
-import deepEqual from "deep-equal";
 import { nanoid as createId } from "nanoid";
 import { FunctionEventSource } from "../../core/FunctionEventSource.js";
 import { getGlobalFunctionLogging } from "../../core/GlobalFunctionLogging.js";
@@ -7,6 +6,7 @@ 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";
 export function streamStructure(model, structureDefinition, prompt, options) {
@@ -84,9 +84,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
                     const latestFullDelta = event.fullDelta;
                     const latestStructure = event.valueDelta;
                     // only send a new part into the stream when the partial structure has changed:
-                    if (!deepEqual(lastStructure, latestStructure, {
-                        strict: true,
-                    })) {
+                    if (!isDeepEqualData(lastStructure, latestStructure)) {
                         lastFullDelta = latestFullDelta;
                         lastStructure = latestStructure;
                         yield {

package/{prompt → model-function/generate-text}/AlpacaPromptFormat.d.ts

@@ -1,5 +1,5 @@
 import { InstructionPrompt } from "./InstructionPrompt.js";
-import { PromptFormat } from "./PromptFormat.js";
+import { TextGenerationPromptFormat } from "./TextGenerationPromptFormat.js";
 /**
  * Formats an instruction prompt as an Alpaca prompt.
  *
@@ -8,4 +8,4 @@ import { PromptFormat } from "./PromptFormat.js";
  *
  * @see https://github.com/tatsu-lab/stanford_alpaca#data-release
  */
-export declare function mapInstructionPromptToAlpacaFormat(): PromptFormat<InstructionPrompt, string>;
+export declare function mapInstructionPromptToAlpacaFormat(): TextGenerationPromptFormat<InstructionPrompt, string>;

package/{prompt → model-function/generate-text}/Llama2PromptFormat.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapChatPromptToLlama2Format = exports.mapInstructionPromptToLlama2Format = void 0;
-const validateChatPrompt_js_1 = require("./chat/validateChatPrompt.cjs");
+const validateChatPrompt_js_1 = require("./validateChatPrompt.cjs");
 // see https://github.com/facebookresearch/llama/blob/6c7fe276574e78057f917549435a2554000a876d/llama/generation.py#L44
 const BEGIN_SEGMENT = "<s>";
 const END_SEGMENT = "</s>\n";

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

@@ -0,0 +1,13 @@
+import { ChatPrompt } from "./ChatPrompt.js";
+import { InstructionPrompt } from "./InstructionPrompt.js";
+import { TextGenerationPromptFormat } from "./TextGenerationPromptFormat.js";
+/**
+ * Formats an instruction prompt as a Llama 2 prompt.
+ *
+ * @see https://www.philschmid.de/llama-2#how-to-prompt-llama-2-chat
+ */
+export declare function mapInstructionPromptToLlama2Format(): TextGenerationPromptFormat<InstructionPrompt, string>;
+/**
+ * Formats a chat prompt as a Llama 2 prompt.
+ */
+export declare function mapChatPromptToLlama2Format(): TextGenerationPromptFormat<ChatPrompt, string>;

package/{prompt → model-function/generate-text}/Llama2PromptFormat.js

@@ -1,4 +1,4 @@
-import { validateChatPrompt } from "./chat/validateChatPrompt.js";
+import { validateChatPrompt } from "./validateChatPrompt.js";
 // see https://github.com/facebookresearch/llama/blob/6c7fe276574e78057f917549435a2554000a876d/llama/generation.py#L44
 const BEGIN_SEGMENT = "<s>";
 const END_SEGMENT = "</s>\n";

package/{prompt → model-function/generate-text}/PromptFormatTextGenerationModel.d.ts

@@ -1,14 +1,14 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
-import { TextGenerationModel, TextGenerationModelSettings } from "../model-function/generate-text/TextGenerationModel.js";
-import { PromptFormat } from "./PromptFormat.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
+import { TextGenerationPromptFormat } from "./TextGenerationPromptFormat.js";
 export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, SETTINGS extends TextGenerationModelSettings, MODEL extends TextGenerationModel<MODEL_PROMPT, SETTINGS>> implements TextGenerationModel<PROMPT, SETTINGS> {
     readonly model: MODEL;
-    readonly promptFormat: PromptFormat<PROMPT, MODEL_PROMPT>;
+    readonly promptFormat: TextGenerationPromptFormat<PROMPT, MODEL_PROMPT>;
     constructor({ model, promptFormat, }: {
         model: MODEL;
-        promptFormat: PromptFormat<PROMPT, MODEL_PROMPT>;
+        promptFormat: TextGenerationPromptFormat<PROMPT, MODEL_PROMPT>;
     });
-    get modelInformation(): import("../index.js").ModelInformation;
+    get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): SETTINGS;
     get tokenizer(): MODEL["tokenizer"];
     get contextWindowSize(): MODEL["contextWindowSize"];
@@ -23,6 +23,6 @@ export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, SETTI
         } | undefined;
     }>;
     get settingsForEvent(): Partial<SETTINGS>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: TextGenerationPromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }