modelfusion 0.33.0 → 0.34.0

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -1,8 +1,8 @@
 import SecureJSON from "secure-json-parse";
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
-import { parseEventSourceReadableStream } from "../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
@@ -208,14 +208,11 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     let content = "";
     // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            try {
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
                 const json = SecureJSON.parse(data);
                 const parseResult = llamaCppTextStreamingResponseSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -226,26 +223,29 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                content += event.content;
+                const eventData = parseResult.data;
+                content += eventData.content;
                 queue.push({
                     type: "delta",
                     fullDelta: {
                         content,
-                        isComplete: event.stop,
-                        delta: event.content,
+                        isComplete: eventData.stop,
+                        delta: eventData.content,
                     },
                 });
-                if (event.stop) {
+                if (eventData.stop) {
                     queue.close();
                 }
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
     });
     return queue;
 }

package/model-provider/lmnt/LmntSpeechSynthesisModel.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";

package/model-provider/openai/OpenAITextGenerationModel.cjs

@@ -7,8 +7,8 @@ exports.OpenAITextResponseFormat = exports.OpenAITextGenerationModel = exports.c
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = __importDefault(require("zod"));
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const AsyncQueue_js_1 = require("../../model-function/generate-text/AsyncQueue.cjs");
-const parseEventSourceReadableStream_js_1 = require("../../model-function/generate-text/parseEventSourceReadableStream.cjs");
+const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
 const PromptFormatTextGenerationModel_js_1 = require("../../prompt/PromptFormatTextGenerationModel.cjs");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
@@ -335,18 +335,15 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = secure_json_parse_1.default.parse(data);
                 const parseResult = textResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -357,9 +354,9 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.text;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -383,12 +380,17 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

package/model-provider/openai/OpenAITextGenerationModel.js

@@ -1,8 +1,8 @@
 import SecureJSON from "secure-json-parse";
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
-import { parseEventSourceReadableStream } from "../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
@@ -325,18 +325,15 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = SecureJSON.parse(data);
                 const parseResult = textResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -347,9 +344,9 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.text;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -373,12 +370,17 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

package/model-provider/openai/OpenAITranscriptionModel.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";

package/model-provider/openai/chat/OpenAIChatStreamIterable.cjs

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAIChatFullDeltaIterableQueue = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
-const AsyncQueue_js_1 = require("../../../model-function/generate-text/AsyncQueue.cjs");
-const parseEventSourceReadableStream_js_1 = require("../../../model-function/generate-text/parseEventSourceReadableStream.cjs");
+const AsyncQueue_js_1 = require("../../../event-source/AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("../../../event-source/parseEventSourceStream.cjs");
 const chatResponseStreamEventSchema = zod_1.z.object({
     choices: zod_1.z.array(zod_1.z.object({
         delta: zod_1.z.object({
@@ -32,18 +32,15 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = secure_json_parse_1.default.parse(data);
                 const parseResult = chatResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -54,9 +51,9 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.delta;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -85,7 +82,8 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
                             choice.function_call.name += delta.function_call.name;
                         }
                         if (delta.function_call.arguments != undefined) {
-                            choice.function_call.arguments += delta.function_call.arguments;
+                            choice.function_call.arguments +=
+                                delta.function_call.arguments;
                         }
                     }
                     if (delta.role != undefined) {
@@ -100,12 +98,17 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

package/model-provider/openai/chat/OpenAIChatStreamIterable.js

@@ -1,7 +1,7 @@
 import SecureJSON from "secure-json-parse";
 import { z } from "zod";
-import { AsyncQueue } from "../../../model-function/generate-text/AsyncQueue.js";
-import { parseEventSourceReadableStream } from "../../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { AsyncQueue } from "../../../event-source/AsyncQueue.js";
+import { parseEventSourceStream } from "../../../event-source/parseEventSourceStream.js";
 const chatResponseStreamEventSchema = z.object({
     choices: z.array(z.object({
         delta: z.object({
@@ -26,18 +26,15 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = SecureJSON.parse(data);
                 const parseResult = chatResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -48,9 +45,9 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.delta;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -79,7 +76,8 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
                             choice.function_call.name += delta.function_call.name;
                         }
                         if (delta.function_call.arguments != undefined) {
-                            choice.function_call.arguments += delta.function_call.arguments;
+                            choice.function_call.arguments +=
+                                delta.function_call.arguments;
                         }
                     }
                     if (delta.role != undefined) {
@@ -94,12 +92,17 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -51,7 +51,7 @@
     "dist": "npm run clean && npm run lint && npm run build && npm run dist:copy-files"
   },
   "dependencies": {
-    "eventsource-parser": "1.0.0",
+    "eventsource-parser": "1.1.1",
     "js-tiktoken": "1.0.7",
     "nanoid": "3.3.6",
     "secure-json-parse": "2.7.0",
@@ -60,7 +60,7 @@
   },
   "devDependencies": {
     "@pinecone-database/pinecone": "^0.1.6",
-    "@tsconfig/recommended": "1.0.2",
+    "@tsconfig/recommended": "1.0.3",
     "@types/node": "18.11.9",
     "@typescript-eslint/eslint-plugin": "^6.1.0",
     "@typescript-eslint/parser": "^6.1.0",
@@ -71,10 +71,10 @@
     "lint-staged": "14.0.1",
     "prettier": "3.0.3",
     "rimraf": "5.0.1",
-    "typescript": "5.1.6"
+    "typescript": "5.2.2"
   },
   "peerDependencies": {
-    "@pinecone-database/pinecone": "*"
+    "@pinecone-database/pinecone": "0.1.6"
   },
   "peerDependenciesMeta": {
     "@pinecone-database/pinecone": {

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

@@ -1,17 +0,0 @@
-/**
- * @internal
- */
-export declare class AsyncQueue<T> implements AsyncIterable<T | undefined> {
-    queue: T[];
-    resolvers: Array<(options: {
-        value: T | undefined;
-        done: boolean;
-    }) => void>;
-    closed: boolean;
-    constructor();
-    push(value: T): void;
-    close(): void;
-    [Symbol.asyncIterator](): {
-        next: () => Promise<IteratorResult<T | undefined, T | undefined>>;
-    };
-}

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

@@ -1,54 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTextDeltaEventSource = exports.createTextDeltaEventSource = void 0;
-const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
-const zod_1 = require("zod");
-const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
-const parseEventSourceReadableStream_js_1 = require("./parseEventSourceReadableStream.cjs");
-const textEncoder = new TextEncoder();
-const textDeltaEventDataSchema = zod_1.z.object({
-    textDelta: zod_1.z.string().optional(),
-    isFinished: zod_1.z.boolean(),
-});
-function enqueueData(controller, data) {
-    controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(data)}\n\n`));
-}
-function createTextDeltaEventSource(textDeltas) {
-    return new ReadableStream({
-        async start(controller) {
-            for await (const textDelta of textDeltas) {
-                enqueueData(controller, { textDelta, isFinished: false });
-            }
-            enqueueData(controller, { isFinished: true });
-        },
-    });
-}
-exports.createTextDeltaEventSource = createTextDeltaEventSource;
-function parseTextDeltaEventSource(stream, options) {
-    const queue = new AsyncQueue_js_1.AsyncQueue();
-    // run async (no await on purpose):
-    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            try {
-                const data = textDeltaEventDataSchema.parse(secure_json_parse_1.default.parse(event.data));
-                queue.push(data.textDelta);
-                if (data.isFinished) {
-                    queue.close();
-                }
-            }
-            catch (error) {
-                options?.errorHandler(error);
-                queue.close();
-            }
-        },
-    });
-    return queue;
-}
-exports.parseTextDeltaEventSource = parseTextDeltaEventSource;

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

@@ -1,5 +0,0 @@
-import { ErrorHandler } from "../../util/ErrorHandler.js";
-export declare function createTextDeltaEventSource(textDeltas: AsyncIterable<string>): ReadableStream<any>;
-export declare function parseTextDeltaEventSource(stream: ReadableStream<Uint8Array>, options?: {
-    errorHandler: ErrorHandler;
-}): AsyncIterable<string | undefined>;

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

@@ -1,46 +0,0 @@
-import SecureJSON from "secure-json-parse";
-import { z } from "zod";
-import { AsyncQueue } from "./AsyncQueue.js";
-import { parseEventSourceReadableStream } from "./parseEventSourceReadableStream.js";
-const textEncoder = new TextEncoder();
-const textDeltaEventDataSchema = z.object({
-    textDelta: z.string().optional(),
-    isFinished: z.boolean(),
-});
-function enqueueData(controller, data) {
-    controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(data)}\n\n`));
-}
-export function createTextDeltaEventSource(textDeltas) {
-    return new ReadableStream({
-        async start(controller) {
-            for await (const textDelta of textDeltas) {
-                enqueueData(controller, { textDelta, isFinished: false });
-            }
-            enqueueData(controller, { isFinished: true });
-        },
-    });
-}
-export function parseTextDeltaEventSource(stream, options) {
-    const queue = new AsyncQueue();
-    // run async (no await on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            try {
-                const data = textDeltaEventDataSchema.parse(SecureJSON.parse(event.data));
-                queue.push(data.textDelta);
-                if (data.isFinished) {
-                    queue.close();
-                }
-            }
-            catch (error) {
-                options?.errorHandler(error);
-                queue.close();
-            }
-        },
-    });
-    return queue;
-}

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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEventSourceReadableStream = void 0;
-const eventsource_parser_1 = require("eventsource-parser");
-async function* convertReadableStreamToAsyncIterable(reader) {
-    while (true) {
-        const result = await reader.read();
-        if (result.done) {
-            break;
-        }
-        yield result.value;
-    }
-}
-/**
- * @internal
- */
-async function parseEventSourceReadableStream({ stream, callback, }) {
-    try {
-        const parser = (0, eventsource_parser_1.createParser)(callback);
-        const decoder = new TextDecoder();
-        const iterable = convertReadableStreamToAsyncIterable(stream.getReader());
-        for await (const value of iterable) {
-            parser.feed(decoder.decode(value));
-        }
-    }
-    catch (error) {
-        console.error(error); // TODO introduce error handler param
-    }
-}
-exports.parseEventSourceReadableStream = parseEventSourceReadableStream;

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

@@ -1,8 +0,0 @@
-import { EventSourceParseCallback } from "eventsource-parser";
-/**
- * @internal
- */
-export declare function parseEventSourceReadableStream({ stream, callback, }: {
-    stream: ReadableStream<Uint8Array>;
-    callback: EventSourceParseCallback;
-}): Promise<void>;

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

@@ -1,26 +0,0 @@
-import { createParser } from "eventsource-parser";
-async function* convertReadableStreamToAsyncIterable(reader) {
-    while (true) {
-        const result = await reader.read();
-        if (result.done) {
-            break;
-        }
-        yield result.value;
-    }
-}
-/**
- * @internal
- */
-export async function parseEventSourceReadableStream({ stream, callback, }) {
-    try {
-        const parser = createParser(callback);
-        const decoder = new TextDecoder();
-        const iterable = convertReadableStreamToAsyncIterable(stream.getReader());
-        for await (const value of iterable) {
-            parser.feed(decoder.decode(value));
-        }
-    }
-    catch (error) {
-        console.error(error); // TODO introduce error handler param
-    }
-}