modelfusion 0.47.0 → 0.47.2

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

@@ -26,7 +26,7 @@ function generateStructure(model, structureDefinition, prompt, options) {
                     cause: parseResult.error,
                 });
             }
-            const value = parseResult.value;
+            const value = parseResult.data;
             return {
                 response: result.response,
                 extractedValue: value,

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

@@ -23,7 +23,7 @@ export function generateStructure(model, structureDefinition, prompt, options) {
                     cause: parseResult.error,
                 });
             }
-            const value = parseResult.value;
+            const value = parseResult.data;
             return {
                 response: result.response,
                 extractedValue: value,

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

@@ -43,7 +43,7 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
                 response: result.response,
                 extractedValue: {
                     structure: structure,
-                    value: parseResult.value,
+                    value: parseResult.data,
                     text: text, // text is string | null, which is part of the response for schema values
                 },
                 usage: result.usage,

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

@@ -40,7 +40,7 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
                 response: result.response,
                 extractedValue: {
                     structure: structure,
-                    value: parseResult.value,
+                    value: parseResult.data,
                     text: text, // text is string | null, which is part of the response for schema values
                 },
                 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 {
@@ -111,7 +106,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
             }
             yield {
                 isComplete: true,
-                value: parseResult.value,
+                value: parseResult.data,
             };
             const finishMetadata = {
                 eventType: "finished",

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 {
@@ -104,7 +102,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
             }
             yield {
                 isComplete: true,
-                value: parseResult.value,
+                value: parseResult.data,
             };
             const finishMetadata = {
                 eventType: "finished",

package/model-provider/anthropic/AnthropicError.cjs

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.failedAnthropicCallResponseHandler = exports.AnthropicError = exports.anthropicErrorDataSchema = void 0;
-const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
+const parseJSON_js_1 = require("../../util/parseJSON.cjs");
 exports.anthropicErrorDataSchema = zod_1.z.object({
     error: zod_1.z.object({
         type: zod_1.z.string(),
@@ -26,14 +23,10 @@ class AnthropicError extends ApiCallError_js_1.ApiCallError {
     }
 }
 exports.AnthropicError = AnthropicError;
-const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => {
-    const responseBody = await response.text();
-    const parsedError = exports.anthropicErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
-    return new AnthropicError({
-        url,
-        requestBodyValues,
-        statusCode: response.status,
-        data: parsedError,
-    });
-};
+const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => new AnthropicError({
+    url,
+    requestBodyValues,
+    statusCode: response.status,
+    data: (0, parseJSON_js_1.parseJsonWithZod)(await response.text(), exports.anthropicErrorDataSchema),
+});
 exports.failedAnthropicCallResponseHandler = failedAnthropicCallResponseHandler;

package/model-provider/anthropic/AnthropicError.js

@@ -1,6 +1,6 @@
-import SecureJSON from "secure-json-parse";
 import { z } from "zod";
 import { ApiCallError } from "../../core/api/ApiCallError.js";
+import { parseJsonWithZod } from "../../util/parseJSON.js";
 export const anthropicErrorDataSchema = z.object({
     error: z.object({
         type: z.string(),
@@ -19,13 +19,9 @@ export class AnthropicError extends ApiCallError {
         this.data = data;
     }
 }
-export const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => {
-    const responseBody = await response.text();
-    const parsedError = anthropicErrorDataSchema.parse(SecureJSON.parse(responseBody));
-    return new AnthropicError({
-        url,
-        requestBodyValues,
-        statusCode: response.status,
-        data: parsedError,
-    });
-};
+export const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => new AnthropicError({
+    url,
+    requestBodyValues,
+    statusCode: response.status,
+    data: parseJsonWithZod(await response.text(), anthropicErrorDataSchema),
+});

package/model-provider/anthropic/AnthropicTextGenerationModel.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.AnthropicTextGenerationResponseFormat = exports.AnthropicTextGenerationModel = exports.ANTHROPIC_TEXT_GENERATION_MODELS = void 0;
-const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
@@ -12,6 +8,7 @@ const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");
+const parseJSON_js_1 = require("../../util/parseJSON.cjs");
 const AnthropicApiConfiguration_js_1 = require("./AnthropicApiConfiguration.cjs");
 const AnthropicError_js_1 = require("./AnthropicError.cjs");
 const AnthropicPromptFormat_js_1 = require("./AnthropicPromptFormat.cjs");
@@ -183,17 +180,7 @@ async function createAnthropicFullDeltaIterableQueue(stream) {
                     continue;
                 }
                 const data = event.data;
-                const json = secure_json_parse_1.default.parse(data);
-                const parseResult = anthropicTextStreamingResponseSchema.safeParse(json);
-                if (!parseResult.success) {
-                    queue.push({
-                        type: "error",
-                        error: parseResult.error,
-                    });
-                    queue.close();
-                    return;
-                }
-                const eventData = parseResult.data;
+                const eventData = (0, parseJSON_js_1.parseJsonWithZod)(data, anthropicTextStreamingResponseSchema);
                 content += eventData.completion;
                 queue.push({
                     type: "delta",

package/model-provider/anthropic/AnthropicTextGenerationModel.js

@@ -1,4 +1,3 @@
-import SecureJSON from "secure-json-parse";
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
@@ -6,6 +5,7 @@ import { AsyncQueue } from "../../event-source/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
+import { parseJsonWithZod } from "../../util/parseJSON.js";
 import { AnthropicApiConfiguration } from "./AnthropicApiConfiguration.js";
 import { failedAnthropicCallResponseHandler } from "./AnthropicError.js";
 import { mapChatPromptToAnthropicFormat, mapInstructionPromptToAnthropicFormat, } from "./AnthropicPromptFormat.js";
@@ -176,17 +176,7 @@ async function createAnthropicFullDeltaIterableQueue(stream) {
                     continue;
                 }
                 const data = event.data;
-                const json = SecureJSON.parse(data);
-                const parseResult = anthropicTextStreamingResponseSchema.safeParse(json);
-                if (!parseResult.success) {
-                    queue.push({
-                        type: "error",
-                        error: parseResult.error,
-                    });
-                    queue.close();
-                    return;
-                }
-                const eventData = parseResult.data;
+                const eventData = parseJsonWithZod(data, anthropicTextStreamingResponseSchema);
                 content += eventData.completion;
                 queue.push({
                     type: "delta",