modelfusion 0.0.44

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+/**
+ * @internal
+ */
+class AsyncQueue {
+    constructor() {
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "resolvers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.queue = [];
+        this.resolvers = [];
+        this.closed = false;
+    }
+    push(value) {
+        if (this.closed) {
+            throw new Error("Pushing to a closed queue");
+        }
+        const resolve = this.resolvers.shift();
+        if (resolve) {
+            resolve({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        while (this.resolvers.length) {
+            const resolve = this.resolvers.shift();
+            resolve?.({ value: undefined, done: true });
+        }
+        this.closed = true;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                else if (this.closed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                else {
+                    return new Promise((resolve) => this.resolvers.push(resolve));
+                }
+            },
+        };
+    }
+}
+exports.AsyncQueue = AsyncQueue;

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

@@ -0,0 +1,17 @@
+/**
+ * @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/AsyncQueue.js

@@ -0,0 +1,62 @@
+/**
+ * @internal
+ */
+export class AsyncQueue {
+    constructor() {
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "resolvers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.queue = [];
+        this.resolvers = [];
+        this.closed = false;
+    }
+    push(value) {
+        if (this.closed) {
+            throw new Error("Pushing to a closed queue");
+        }
+        const resolve = this.resolvers.shift();
+        if (resolve) {
+            resolve({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        while (this.resolvers.length) {
+            const resolve = this.resolvers.shift();
+            resolve?.({ value: undefined, done: true });
+        }
+        this.closed = true;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                else if (this.closed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                else {
+                    return new Promise((resolve) => this.resolvers.push(resolve));
+                }
+            },
+        };
+    }
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+export type DeltaEvent<FULL_DELTA> = {
+    type: "delta";
+    fullDelta: FULL_DELTA;
+} | {
+    type: "error";
+    error: unknown;
+} | undefined;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,54 @@
+"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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,46 @@
+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/TextGenerationEvent.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
+export type TextGenerationStartedEvent = {
+    type: "text-generation-started";
+    metadata: ModelCallStartedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+};
+export type TextGenerationFinishedEvent = {
+    type: "text-generation-finished";
+    metadata: ModelCallFinishedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+} & ({
+    status: "success";
+    response: unknown;
+    generatedText: string;
+} | {
+    status: "failure";
+    error: unknown;
+} | {
+    status: "abort";
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,42 @@
+import { PromptMapping } from "../../prompt/PromptMapping.js";
+import { PromptMappingTextGenerationModel } from "../../prompt/PromptMappingTextGenerationModel.js";
+import { FunctionOptions } from "../FunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
+import { DeltaEvent } from "./DeltaEvent.js";
+export interface TextGenerationModelSettings extends ModelSettings {
+    trimOutput?: boolean;
+}
+export interface TextGenerationModel<PROMPT, RESPONSE, FULL_DELTA, SETTINGS extends TextGenerationModelSettings> extends Model<SETTINGS> {
+    readonly contextWindowSize: number | undefined;
+    readonly tokenizer: BasicTokenizer | FullTokenizer | undefined;
+    /**
+     * Optional. Implement if you have a tokenizer and want to count the number of tokens in a prompt.
+     */
+    readonly countPromptTokens: ((prompt: PROMPT) => PromiseLike<number>) | undefined;
+    generateTextResponse(prompt: PROMPT, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    extractText(response: RESPONSE): string;
+    /**
+     * Optional. Implement for streaming support.
+     */
+    readonly generateDeltaStreamResponse: ((prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>) | undefined;
+    /**
+     * Optional. Implement for streaming support.
+     */
+    readonly extractTextDelta: ((fullDelta: FULL_DELTA) => string | undefined) | undefined;
+    mapPrompt<INPUT_PROMPT>(promptMapping: PromptMapping<INPUT_PROMPT, PROMPT>): PromptMappingTextGenerationModel<INPUT_PROMPT, PROMPT, RESPONSE, FULL_DELTA, SETTINGS, this>;
+    /**
+     * Maximum number of tokens to generate.
+     */
+    readonly maxCompletionTokens: number | undefined;
+    /**
+     * Sets the maximum number of tokens to generate.
+     * Does nothing if the model does not support this setting.
+     */
+    withMaxCompletionTokens(maxCompletionTokens: number): this;
+    /**
+     * Sets the stop tokens to use. Stop tokens are not included in the generated text.
+     * Does nothing if the model does not support this setting.
+     */
+    withStopTokens(stopTokens: string[]): this;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
+export type TextStreamingStartedEvent = {
+    type: "text-streaming-started";
+    metadata: ModelCallStartedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+};
+export type TextStreamingFinishedEvent = {
+    type: "text-streaming-finished";
+    metadata: ModelCallFinishedEventMetadata;
+    settings: unknown;
+    prompt: unknown;
+} & ({
+    status: "success";
+    response: unknown;
+    generatedText: string;
+} | {
+    status: "failure";
+    error: unknown;
+} | {
+    status: "abort";
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,23 @@
+"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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,19 @@
+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/generateText.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateText = void 0;
+const executeCall_js_1 = require("../executeCall.cjs");
+/**
+ * Generates a text using a prompt.
+ * The prompt format depends on the model.
+ * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ *
+ * @example
+ * const model = new OpenAITextGenerationModel(...);
+ *
+ * const { text } = await model.generateText(
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+async function generateText(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+model, prompt, options) {
+    const result = await (0, executeCall_js_1.executeCall)({
+        model,
+        options,
+        generateResponse: (options) => model.generateTextResponse(prompt, options),
+        extractOutputValue: (result) => {
+            const shouldTrimOutput = model.settings.trimOutput ?? true;
+            return shouldTrimOutput
+                ? model.extractText(result).trim()
+                : model.extractText(result);
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "text-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "text-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "text-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "text-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedText: output,
+        }),
+    });
+    return {
+        text: result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}
+exports.generateText = generateText;

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

@@ -0,0 +1,20 @@
+import { FunctionOptions } from "../FunctionOptions.js";
+import { CallMetadata } from "../executeCall.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
+/**
+ * Generates a text using a prompt.
+ * The prompt format depends on the model.
+ * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ *
+ * @example
+ * const model = new OpenAITextGenerationModel(...);
+ *
+ * const { text } = await model.generateText(
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+export declare function generateText<PROMPT, RESPONSE, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): Promise<{
+    text: string;
+    response: RESPONSE;
+    metadata: CallMetadata<TextGenerationModel<PROMPT, RESPONSE, unknown, SETTINGS>>;
+}>;

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

@@ -0,0 +1,63 @@
+import { executeCall } from "../executeCall.js";
+/**
+ * Generates a text using a prompt.
+ * The prompt format depends on the model.
+ * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ *
+ * @example
+ * const model = new OpenAITextGenerationModel(...);
+ *
+ * const { text } = await model.generateText(
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+export async function generateText(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+model, prompt, options) {
+    const result = await executeCall({
+        model,
+        options,
+        generateResponse: (options) => model.generateTextResponse(prompt, options),
+        extractOutputValue: (result) => {
+            const shouldTrimOutput = model.settings.trimOutput ?? true;
+            return shouldTrimOutput
+                ? model.extractText(result).trim()
+                : model.extractText(result);
+        },
+        getStartEvent: (metadata, settings) => ({
+            type: "text-generation-started",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getAbortEvent: (metadata, settings) => ({
+            type: "text-generation-finished",
+            status: "abort",
+            metadata,
+            settings,
+            prompt,
+        }),
+        getFailureEvent: (metadata, settings, error) => ({
+            type: "text-generation-finished",
+            status: "failure",
+            metadata,
+            settings,
+            prompt,
+            error,
+        }),
+        getSuccessEvent: (metadata, settings, response, output) => ({
+            type: "text-generation-finished",
+            status: "success",
+            metadata,
+            settings,
+            prompt,
+            response,
+            generatedText: output,
+        }),
+    });
+    return {
+        text: result.output,
+        response: result.response,
+        metadata: result.metadata,
+    };
+}

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

@@ -0,0 +1,30 @@
+"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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,26 @@
+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
+    }
+}