modelfusion 0.33.1 → 0.35.0

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/extractTextDeltas.cjs

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractTextDeltas = void 0;
-async function* extractTextDeltas({ deltaIterable, extractDelta, onDone, onError, }) {
-    let accumulatedText = "";
-    let lastFullDelta;
-    for await (const event of deltaIterable) {
-        if (event?.type === "error") {
-            onError(event.error);
-            throw event.error;
-        }
-        if (event?.type === "delta") {
-            lastFullDelta = event.fullDelta;
-            const delta = extractDelta(lastFullDelta);
-            if (delta != null && delta.length > 0) {
-                accumulatedText += delta;
-                yield delta;
-            }
-        }
-    }
-    onDone(accumulatedText, lastFullDelta);
-}
-exports.extractTextDeltas = extractTextDeltas;

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

@@ -1,7 +0,0 @@
-import { DeltaEvent } from "./DeltaEvent.js";
-export declare function extractTextDeltas<FULL_DELTA>({ deltaIterable, extractDelta, onDone, onError, }: {
-    deltaIterable: AsyncIterable<DeltaEvent<FULL_DELTA>>;
-    extractDelta: (fullDelta: FULL_DELTA) => string | undefined;
-    onDone: (fullText: string, lastFullDelta: FULL_DELTA | undefined) => void;
-    onError: (error: unknown) => void;
-}): AsyncIterable<string>;

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

@@ -1,19 +0,0 @@
-export async function* extractTextDeltas({ deltaIterable, extractDelta, onDone, onError, }) {
-    let accumulatedText = "";
-    let lastFullDelta;
-    for await (const event of deltaIterable) {
-        if (event?.type === "error") {
-            onError(event.error);
-            throw event.error;
-        }
-        if (event?.type === "delta") {
-            lastFullDelta = event.fullDelta;
-            const delta = extractDelta(lastFullDelta);
-            if (delta != null && delta.length > 0) {
-                accumulatedText += delta;
-                yield delta;
-            }
-        }
-    }
-    onDone(accumulatedText, lastFullDelta);
-}

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
-    }
-}