modelfusion 0.104.0 → 0.106.0

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

@@ -1,63 +0,0 @@
-import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
-/**
- * OpenAIMessage[] identity chat format.
- */
-export function identity() {
-    return { format: (prompt) => prompt, stopSequences: [] };
-}
-/**
- * Formats a text prompt as an OpenAI chat prompt.
- */
-export function text() {
-    return {
-        format: (prompt) => [OpenAIChatMessage.user(prompt)],
-        stopSequences: [],
-    };
-}
-/**
- * Formats an instruction prompt as an OpenAI chat prompt.
- */
-export function instruction() {
-    return {
-        format(prompt) {
-            const messages = [];
-            if (prompt.system != null) {
-                messages.push(OpenAIChatMessage.system(prompt.system));
-            }
-            messages.push(OpenAIChatMessage.user(prompt.instruction));
-            return messages;
-        },
-        stopSequences: [],
-    };
-}
-/**
- * Formats a chat prompt as an OpenAI chat prompt.
- */
-export function chat() {
-    return {
-        format(prompt) {
-            const messages = [];
-            if (prompt.system != null) {
-                messages.push(OpenAIChatMessage.system(prompt.system));
-            }
-            for (const { role, content } of prompt.messages) {
-                switch (role) {
-                    case "user": {
-                        messages.push(OpenAIChatMessage.user(content));
-                        break;
-                    }
-                    case "assistant": {
-                        messages.push(OpenAIChatMessage.assistant(content));
-                        break;
-                    }
-                    default: {
-                        const _exhaustiveCheck = role;
-                        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-                    }
-                }
-            }
-            return messages;
-        },
-        stopSequences: [],
-    };
-}

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

@@ -1,156 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOpenAIChatDeltaIterableQueue = void 0;
-const zod_1 = require("zod");
-const AsyncQueue_js_1 = require("../../../util/AsyncQueue.cjs");
-const parseEventSourceStream_js_1 = require("../../../util/streaming/parseEventSourceStream.cjs");
-const parseJSON_js_1 = require("../../../core/schema/parseJSON.cjs");
-const ZodSchema_js_1 = require("../../../core/schema/ZodSchema.cjs");
-const chatCompletionChunkSchema = zod_1.z.object({
-    object: zod_1.z.literal("chat.completion.chunk"),
-    id: zod_1.z.string(),
-    choices: zod_1.z.array(zod_1.z.object({
-        delta: zod_1.z.object({
-            role: zod_1.z.enum(["assistant", "user"]).optional(),
-            content: zod_1.z.string().nullable().optional(),
-            function_call: zod_1.z
-                .object({
-                name: zod_1.z.string().optional(),
-                arguments: zod_1.z.string().optional(),
-            })
-                .optional(),
-            tool_calls: zod_1.z
-                .array(zod_1.z.object({
-                id: zod_1.z.string(),
-                type: zod_1.z.literal("function"),
-                function: zod_1.z.object({
-                    name: zod_1.z.string(),
-                    arguments: zod_1.z.string(),
-                }),
-            }))
-                .optional(),
-        }),
-        finish_reason: zod_1.z
-            .enum([
-            "stop",
-            "length",
-            "tool_calls",
-            "content_filter",
-            "function_call",
-        ])
-            .nullable()
-            .optional(),
-        index: zod_1.z.number(),
-    })),
-    created: zod_1.z.number(),
-    model: zod_1.z.string(),
-    system_fingerprint: zod_1.z.string().optional().nullable(),
-});
-const chatResponseStreamEventSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.union([
-    chatCompletionChunkSchema,
-    zod_1.z.object({
-        object: zod_1.z.string().refine((obj) => obj !== "chat.completion.chunk", {
-            message: "Object must be 'chat.completion.chunk'",
-        }),
-    }),
-]));
-async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
-    const queue = new AsyncQueue_js_1.AsyncQueue();
-    const streamDelta = [];
-    // process the stream asynchonously (no 'await' on purpose):
-    (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 parseResult = (0, parseJSON_js_1.safeParseJSON)({
-                    text: data,
-                    schema: chatResponseStreamEventSchema,
-                });
-                if (!parseResult.success) {
-                    queue.push({
-                        type: "error",
-                        error: parseResult.error,
-                    });
-                    // Note: the queue is not closed on purpose. Some providers might add additional
-                    // chunks that are not parsable, and ModelFusion should be resilient to that.
-                    continue;
-                }
-                const eventData = parseResult.data;
-                // ignore objects that are not "chat.completion.chunk" events.
-                // Such additional objects are e.g. sent by Azure OpenAI.
-                if (eventData.object !== "chat.completion.chunk") {
-                    continue;
-                }
-                const completionChunk = eventData;
-                // reset delta for all existing streamDeltas
-                for (const delta of streamDelta) {
-                    delta.delta = undefined;
-                }
-                for (let i = 0; i < completionChunk.choices.length; i++) {
-                    const eventChoice = completionChunk.choices[i];
-                    const index = eventChoice.index;
-                    const delta = eventChoice.delta;
-                    if (streamDelta[index] == null) {
-                        streamDelta[index] = {
-                            role: undefined,
-                            content: "",
-                            isComplete: false,
-                            delta,
-                        };
-                    }
-                    const choice = streamDelta[index];
-                    choice.delta = delta;
-                    if (eventChoice.finish_reason != null) {
-                        choice.isComplete = true;
-                    }
-                    if (delta.content != undefined) {
-                        choice.content += delta.content;
-                    }
-                    if (delta.function_call != undefined) {
-                        if (choice.function_call == undefined) {
-                            choice.function_call = {
-                                name: "",
-                                arguments: "",
-                            };
-                        }
-                        if (delta.function_call.name != undefined) {
-                            choice.function_call.name += delta.function_call.name;
-                        }
-                        if (delta.function_call.arguments != undefined) {
-                            choice.function_call.arguments +=
-                                delta.function_call.arguments;
-                        }
-                    }
-                    if (delta.role != undefined) {
-                        choice.role = delta.role;
-                    }
-                }
-                // Since we're mutating the choices array in an async scenario,
-                // we need to make a deep copy:
-                const streamDeltaDeepCopy = JSON.parse(JSON.stringify(streamDelta));
-                queue.push({
-                    type: "delta",
-                    fullDelta: streamDeltaDeepCopy,
-                    valueDelta: extractDeltaValue(streamDeltaDeepCopy),
-                });
-            }
-        }
-        catch (error) {
-            queue.push({ type: "error", error });
-            queue.close();
-            return;
-        }
-    })
-        .catch((error) => {
-        queue.push({ type: "error", error });
-        queue.close();
-        return;
-    });
-    return queue;
-}
-exports.createOpenAIChatDeltaIterableQueue = createOpenAIChatDeltaIterableQueue;

package/model-provider/openai/chat/OpenAIChatStreamIterable.d.ts

@@ -1,19 +0,0 @@
-import { Delta } from "../../../model-function/Delta.js";
-export type OpenAIChatDelta = Array<{
-    role: "assistant" | "user" | undefined;
-    content: string;
-    function_call?: {
-        name: string;
-        arguments: string;
-    };
-    isComplete: boolean;
-    delta: {
-        role?: "assistant" | "user";
-        content?: string | null;
-        function_call?: {
-            name?: string;
-            arguments?: string;
-        };
-    } | undefined;
-}>;
-export declare function createOpenAIChatDeltaIterableQueue<VALUE>(stream: ReadableStream<Uint8Array>, extractDeltaValue: (delta: OpenAIChatDelta) => VALUE): Promise<AsyncIterable<Delta<VALUE>>>;

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

@@ -1,152 +0,0 @@
-import { z } from "zod";
-import { AsyncQueue } from "../../../util/AsyncQueue.js";
-import { parseEventSourceStream } from "../../../util/streaming/parseEventSourceStream.js";
-import { safeParseJSON } from "../../../core/schema/parseJSON.js";
-import { ZodSchema } from "../../../core/schema/ZodSchema.js";
-const chatCompletionChunkSchema = z.object({
-    object: z.literal("chat.completion.chunk"),
-    id: z.string(),
-    choices: z.array(z.object({
-        delta: z.object({
-            role: z.enum(["assistant", "user"]).optional(),
-            content: z.string().nullable().optional(),
-            function_call: z
-                .object({
-                name: z.string().optional(),
-                arguments: z.string().optional(),
-            })
-                .optional(),
-            tool_calls: z
-                .array(z.object({
-                id: z.string(),
-                type: z.literal("function"),
-                function: z.object({
-                    name: z.string(),
-                    arguments: z.string(),
-                }),
-            }))
-                .optional(),
-        }),
-        finish_reason: z
-            .enum([
-            "stop",
-            "length",
-            "tool_calls",
-            "content_filter",
-            "function_call",
-        ])
-            .nullable()
-            .optional(),
-        index: z.number(),
-    })),
-    created: z.number(),
-    model: z.string(),
-    system_fingerprint: z.string().optional().nullable(),
-});
-const chatResponseStreamEventSchema = new ZodSchema(z.union([
-    chatCompletionChunkSchema,
-    z.object({
-        object: z.string().refine((obj) => obj !== "chat.completion.chunk", {
-            message: "Object must be 'chat.completion.chunk'",
-        }),
-    }),
-]));
-export async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
-    const queue = new AsyncQueue();
-    const streamDelta = [];
-    // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceStream({ stream })
-        .then(async (events) => {
-        try {
-            for await (const event of events) {
-                const data = event.data;
-                if (data === "[DONE]") {
-                    queue.close();
-                    return;
-                }
-                const parseResult = safeParseJSON({
-                    text: data,
-                    schema: chatResponseStreamEventSchema,
-                });
-                if (!parseResult.success) {
-                    queue.push({
-                        type: "error",
-                        error: parseResult.error,
-                    });
-                    // Note: the queue is not closed on purpose. Some providers might add additional
-                    // chunks that are not parsable, and ModelFusion should be resilient to that.
-                    continue;
-                }
-                const eventData = parseResult.data;
-                // ignore objects that are not "chat.completion.chunk" events.
-                // Such additional objects are e.g. sent by Azure OpenAI.
-                if (eventData.object !== "chat.completion.chunk") {
-                    continue;
-                }
-                const completionChunk = eventData;
-                // reset delta for all existing streamDeltas
-                for (const delta of streamDelta) {
-                    delta.delta = undefined;
-                }
-                for (let i = 0; i < completionChunk.choices.length; i++) {
-                    const eventChoice = completionChunk.choices[i];
-                    const index = eventChoice.index;
-                    const delta = eventChoice.delta;
-                    if (streamDelta[index] == null) {
-                        streamDelta[index] = {
-                            role: undefined,
-                            content: "",
-                            isComplete: false,
-                            delta,
-                        };
-                    }
-                    const choice = streamDelta[index];
-                    choice.delta = delta;
-                    if (eventChoice.finish_reason != null) {
-                        choice.isComplete = true;
-                    }
-                    if (delta.content != undefined) {
-                        choice.content += delta.content;
-                    }
-                    if (delta.function_call != undefined) {
-                        if (choice.function_call == undefined) {
-                            choice.function_call = {
-                                name: "",
-                                arguments: "",
-                            };
-                        }
-                        if (delta.function_call.name != undefined) {
-                            choice.function_call.name += delta.function_call.name;
-                        }
-                        if (delta.function_call.arguments != undefined) {
-                            choice.function_call.arguments +=
-                                delta.function_call.arguments;
-                        }
-                    }
-                    if (delta.role != undefined) {
-                        choice.role = delta.role;
-                    }
-                }
-                // Since we're mutating the choices array in an async scenario,
-                // we need to make a deep copy:
-                const streamDeltaDeepCopy = JSON.parse(JSON.stringify(streamDelta));
-                queue.push({
-                    type: "delta",
-                    fullDelta: streamDeltaDeepCopy,
-                    valueDelta: extractDeltaValue(streamDeltaDeepCopy),
-                });
-            }
-        }
-        catch (error) {
-            queue.push({ type: "error", error });
-            queue.close();
-            return;
-        }
-    })
-        .catch((error) => {
-        queue.push({ type: "error", error });
-        queue.close();
-        return;
-    });
-    return queue;
-}

package/server/fastify/AssetStorage.cjs

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

package/server/fastify/AssetStorage.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="node" />
-import { FlowRun } from "./FlowRun.js";
-export type Asset = {
-    data: Buffer;
-    contentType: string;
-    name: string;
-};
-export interface AssetStorage {
-    storeAsset(options: {
-        run: FlowRun<unknown>;
-        asset: Asset;
-    }): Promise<void>;
-    readAsset(options: {
-        run: FlowRun<unknown>;
-        assetName: string;
-    }): Promise<Asset | null>;
-}

package/server/fastify/DefaultFlow.cjs

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultFlow = void 0;
-class DefaultFlow {
-    constructor({ schema, process, }) {
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "process", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.schema = schema;
-        this.process = process;
-    }
-}
-exports.DefaultFlow = DefaultFlow;

package/server/fastify/DefaultFlow.d.ts

@@ -1,16 +0,0 @@
-import { FlowRun } from "./FlowRun.js";
-import { FlowSchema } from "./FlowSchema.js";
-export declare class DefaultFlow<INPUT, EVENT> {
-    readonly schema: FlowSchema<INPUT, EVENT>;
-    constructor({ schema, process, }: {
-        schema: FlowSchema<INPUT, EVENT>;
-        process: (options: {
-            input: INPUT;
-            run: FlowRun<EVENT>;
-        }) => Promise<void>;
-    });
-    process: (options: {
-        input: INPUT;
-        run: FlowRun<EVENT>;
-    }) => Promise<void>;
-}

package/server/fastify/DefaultFlow.js

@@ -1,18 +0,0 @@
-export class DefaultFlow {
-    constructor({ schema, process, }) {
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "process", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.schema = schema;
-        this.process = process;
-    }
-}

package/server/fastify/FileSystemAssetStorage.cjs

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemAssetStorage = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-class FileSystemAssetStorage {
-    constructor({ path, logger, }) {
-        Object.defineProperty(this, "path", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "logger", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.path = path;
-        this.logger = logger;
-    }
-    async storeAsset({ run, asset, }) {
-        try {
-            const assetPath = this.path(run);
-            await node_fs_1.promises.mkdir(assetPath, { recursive: true });
-            await node_fs_1.promises.writeFile((0, node_path_1.join)(assetPath, asset.name), asset.data);
-            await node_fs_1.promises.writeFile((0, node_path_1.join)(assetPath, `${asset.name}.meta.json`), JSON.stringify({
-                name: asset.name,
-                contentType: asset.contentType,
-            }));
-        }
-        catch (error) {
-            this.logger.logError({
-                run,
-                message: `Failed to store asset ${asset.name}`,
-                error,
-            });
-            throw error;
-        }
-    }
-    async readAsset(options) {
-        try {
-            const assetPath = this.path(options.run);
-            const data = await node_fs_1.promises.readFile((0, node_path_1.join)(assetPath, options.assetName));
-            const meta = await node_fs_1.promises.readFile((0, node_path_1.join)(assetPath, `${options.assetName}.meta.json`));
-            const { name, contentType } = JSON.parse(meta.toString());
-            return { data, name, contentType };
-        }
-        catch (error) {
-            this.logger.logError({
-                run: options.run,
-                message: `Failed to read asset ${options.assetName}`,
-                error,
-            });
-            throw error;
-        }
-    }
-}
-exports.FileSystemAssetStorage = FileSystemAssetStorage;

package/server/fastify/FileSystemAssetStorage.d.ts

@@ -1,19 +0,0 @@
-import type { Asset, AssetStorage } from "./AssetStorage.js";
-import { FlowRun } from "./FlowRun.js";
-import { Logger } from "./Logger.js";
-export declare class FileSystemAssetStorage implements AssetStorage {
-    private readonly path;
-    private readonly logger;
-    constructor({ path, logger, }: {
-        path: (run: FlowRun<unknown>) => string;
-        logger: Logger;
-    });
-    storeAsset({ run, asset, }: {
-        run: FlowRun<unknown>;
-        asset: Asset;
-    }): Promise<void>;
-    readAsset(options: {
-        run: FlowRun<unknown>;
-        assetName: string;
-    }): Promise<Asset | null>;
-}

package/server/fastify/FileSystemAssetStorage.js

@@ -1,56 +0,0 @@
-import { promises as fs } from "node:fs";
-import { join } from "node:path";
-export class FileSystemAssetStorage {
-    constructor({ path, logger, }) {
-        Object.defineProperty(this, "path", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "logger", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.path = path;
-        this.logger = logger;
-    }
-    async storeAsset({ run, asset, }) {
-        try {
-            const assetPath = this.path(run);
-            await fs.mkdir(assetPath, { recursive: true });
-            await fs.writeFile(join(assetPath, asset.name), asset.data);
-            await fs.writeFile(join(assetPath, `${asset.name}.meta.json`), JSON.stringify({
-                name: asset.name,
-                contentType: asset.contentType,
-            }));
-        }
-        catch (error) {
-            this.logger.logError({
-                run,
-                message: `Failed to store asset ${asset.name}`,
-                error,
-            });
-            throw error;
-        }
-    }
-    async readAsset(options) {
-        try {
-            const assetPath = this.path(options.run);
-            const data = await fs.readFile(join(assetPath, options.assetName));
-            const meta = await fs.readFile(join(assetPath, `${options.assetName}.meta.json`));
-            const { name, contentType } = JSON.parse(meta.toString());
-            return { data, name, contentType };
-        }
-        catch (error) {
-            this.logger.logError({
-                run: options.run,
-                message: `Failed to read asset ${options.assetName}`,
-                error,
-            });
-            throw error;
-        }
-    }
-}

package/server/fastify/FileSystemLogger.cjs

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemLogger = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-class FileSystemLogger {
-    constructor({ path }) {
-        Object.defineProperty(this, "logPath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.logPath = path;
-    }
-    async logFunctionEvent({ run, event, }) {
-        const timestamp = event.startTimestamp.getTime();
-        try {
-            const logPath = this.logPath(run);
-            await node_fs_1.promises.mkdir(logPath, { recursive: true });
-            await node_fs_1.promises.writeFile((0, node_path_1.join)(logPath, `${timestamp}-${event.callId}-${event.functionId ?? event.functionType}-${event.eventType}.json`), JSON.stringify(event));
-        }
-        catch (error) {
-            this.logError({
-                run,
-                message: `Failed to write function event ${event.callId}`,
-                error,
-            });
-        }
-    }
-    async logError({ run, error, message, }) {
-        const timestamp = Date.now();
-        try {
-            const logPath = this.logPath(run);
-            await node_fs_1.promises.mkdir(logPath, { recursive: true });
-            await node_fs_1.promises.writeFile((0, node_path_1.join)(logPath, `${timestamp}-error.json`), JSON.stringify({
-                timestamp: new Date(timestamp).toISOString(),
-                runId: run.runId,
-                message,
-                error,
-            }));
-        }
-        catch (error) {
-            console.error(`Failed to write error log`);
-            console.error(error);
-        }
-    }
-}
-exports.FileSystemLogger = FileSystemLogger;

package/server/fastify/FileSystemLogger.d.ts

@@ -1,18 +0,0 @@
-import { FunctionEvent } from "../../core/FunctionEvent.js";
-import { FlowRun } from "./FlowRun.js";
-import { Logger } from "./Logger.js";
-export declare class FileSystemLogger implements Logger {
-    private readonly logPath;
-    constructor({ path }: {
-        path: (run: FlowRun<unknown>) => string;
-    });
-    logFunctionEvent({ run, event, }: {
-        run: FlowRun<unknown>;
-        event: FunctionEvent;
-    }): Promise<void>;
-    logError({ run, error, message, }: {
-        run: FlowRun<unknown>;
-        message: string;
-        error: unknown;
-    }): Promise<void>;
-}