modelfusion 0.53.1 → 0.54.0

package/server/fastify/FileSystemAssetStorage.js

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

@@ -0,0 +1,48 @@
+"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(options) {
+        const timestamp = Date.now();
+        try {
+            const logPath = this.logPath(options.run);
+            return node_fs_1.promises.writeFile((0, node_path_1.join)(logPath, `${timestamp}-error.json`), JSON.stringify({
+                timestamp: new Date(timestamp).toISOString(),
+                runId: options.run.runId,
+                message: options.message,
+                error: options.error,
+            }));
+        }
+        catch (error) {
+            console.error(`Failed to write error log`);
+            console.error(error);
+        }
+    }
+}
+exports.FileSystemLogger = FileSystemLogger;

package/server/fastify/FileSystemLogger.d.ts

@@ -0,0 +1,18 @@
+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(options: {
+        run: FlowRun<unknown>;
+        message: string;
+        error: unknown;
+    }): Promise<void>;
+}

package/server/fastify/FileSystemLogger.js

@@ -0,0 +1,44 @@
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+export 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 fs.mkdir(logPath, { recursive: true });
+            await fs.writeFile(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(options) {
+        const timestamp = Date.now();
+        try {
+            const logPath = this.logPath(options.run);
+            return fs.writeFile(join(logPath, `${timestamp}-error.json`), JSON.stringify({
+                timestamp: new Date(timestamp).toISOString(),
+                runId: options.run.runId,
+                message: options.message,
+                error: options.error,
+            }));
+        }
+        catch (error) {
+            console.error(`Failed to write error log`);
+            console.error(error);
+        }
+    }
+}

package/server/fastify/Flow.cjs

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

package/server/fastify/Flow.d.ts

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

package/server/fastify/Flow.js

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

package/server/fastify/FlowRun.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowRun = void 0;
+const DefaultRun_js_1 = require("../../core/DefaultRun.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
+class FlowRun extends DefaultRun_js_1.DefaultRun {
+    constructor({ paths, assetStorage, logger, }) {
+        super();
+        Object.defineProperty(this, "eventQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AsyncQueue_js_1.AsyncQueue()
+        });
+        Object.defineProperty(this, "assetStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "paths", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "functionObserver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                onFunctionEvent: async (event) => {
+                    this.logger.logFunctionEvent({
+                        run: this,
+                        event,
+                    });
+                },
+            }
+        });
+        this.paths = paths;
+        this.assetStorage = assetStorage;
+        this.logger = logger;
+    }
+    publishEvent(event) {
+        this.eventQueue.push(event);
+    }
+    async storeBinaryAsset(asset) {
+        await this.assetStorage.storeAsset({
+            run: this,
+            asset,
+        });
+        return this.paths.getAssetUrl(this.runId, asset.name);
+    }
+    async storeTextAsset(asset) {
+        return this.storeBinaryAsset({
+            data: Buffer.from(asset.text),
+            contentType: asset.contentType,
+            name: asset.name,
+        });
+    }
+    finish() {
+        this.eventQueue.close();
+    }
+}
+exports.FlowRun = FlowRun;

package/server/fastify/FlowRun.d.ts

@@ -0,0 +1,28 @@
+import { DefaultRun } from "../../core/DefaultRun.js";
+import { FunctionEvent } from "../../core/FunctionEvent.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
+import { Asset, AssetStorage } from "./AssetStorage.js";
+import { Logger } from "./Logger.js";
+import { PathProvider } from "./PathProvider.js";
+export declare class FlowRun<EVENT> extends DefaultRun {
+    readonly eventQueue: AsyncQueue<EVENT>;
+    private readonly assetStorage;
+    private readonly logger;
+    private readonly paths;
+    constructor({ paths, assetStorage, logger, }: {
+        paths: PathProvider;
+        assetStorage: AssetStorage;
+        logger: Logger;
+    });
+    readonly functionObserver: {
+        onFunctionEvent: (event: FunctionEvent) => Promise<void>;
+    };
+    publishEvent(event: EVENT): void;
+    storeBinaryAsset(asset: Asset): Promise<string>;
+    storeTextAsset(asset: {
+        text: string;
+        contentType: string;
+        name: string;
+    }): Promise<string>;
+    finish(): void;
+}

package/server/fastify/FlowRun.js

@@ -0,0 +1,67 @@
+import { DefaultRun } from "../../core/DefaultRun.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
+export class FlowRun extends DefaultRun {
+    constructor({ paths, assetStorage, logger, }) {
+        super();
+        Object.defineProperty(this, "eventQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AsyncQueue()
+        });
+        Object.defineProperty(this, "assetStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "paths", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "functionObserver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                onFunctionEvent: async (event) => {
+                    this.logger.logFunctionEvent({
+                        run: this,
+                        event,
+                    });
+                },
+            }
+        });
+        this.paths = paths;
+        this.assetStorage = assetStorage;
+        this.logger = logger;
+    }
+    publishEvent(event) {
+        this.eventQueue.push(event);
+    }
+    async storeBinaryAsset(asset) {
+        await this.assetStorage.storeAsset({
+            run: this,
+            asset,
+        });
+        return this.paths.getAssetUrl(this.runId, asset.name);
+    }
+    async storeTextAsset(asset) {
+        return this.storeBinaryAsset({
+            data: Buffer.from(asset.text),
+            contentType: asset.contentType,
+            name: asset.name,
+        });
+    }
+    finish() {
+        this.eventQueue.close();
+    }
+}

package/server/fastify/FlowSchema.cjs

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

package/server/fastify/FlowSchema.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export interface FlowSchema<INPUT, EVENT> {
+    input: z.ZodType<INPUT>;
+    events: z.ZodType<EVENT>;
+}

package/server/fastify/FlowSchema.js

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

package/server/fastify/Logger.cjs

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

package/server/fastify/Logger.d.ts

@@ -0,0 +1,13 @@
+import { FunctionEvent } from "../../core/FunctionEvent.js";
+import { FlowRun } from "./FlowRun.js";
+export interface Logger {
+    logFunctionEvent(options: {
+        run: FlowRun<unknown>;
+        event: FunctionEvent;
+    }): Promise<void>;
+    logError(options: {
+        run: FlowRun<unknown>;
+        message: string;
+        error: unknown;
+    }): Promise<void>;
+}

package/server/fastify/Logger.js

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

package/server/fastify/PathProvider.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathProvider = void 0;
+class PathProvider {
+    constructor({ baseUrl, basePath }) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "basePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.baseUrl = baseUrl;
+        this.basePath = basePath;
+    }
+    getAssetUrl(runId, assetName) {
+        return `${this.baseUrl}${this.basePath}/${runId}/assets/${assetName}`;
+    }
+    getAssetPathTemplate() {
+        return `${this.basePath}/:runId/assets/:assetName`;
+    }
+    getEventsUrl(runId) {
+        return `${this.baseUrl}${this.basePath}/${runId}/events`;
+    }
+    getEventsPathTemplate() {
+        return `${this.basePath}/:runId/events`;
+    }
+}
+exports.PathProvider = PathProvider;

package/server/fastify/PathProvider.d.ts

@@ -0,0 +1,12 @@
+export declare class PathProvider {
+    readonly baseUrl: string;
+    readonly basePath: string;
+    constructor({ baseUrl, basePath }: {
+        baseUrl: string;
+        basePath: string;
+    });
+    getAssetUrl(runId: string, assetName: string): string;
+    getAssetPathTemplate(): string;
+    getEventsUrl(runId: string): string;
+    getEventsPathTemplate(): string;
+}

package/server/fastify/PathProvider.js

@@ -0,0 +1,30 @@
+export class PathProvider {
+    constructor({ baseUrl, basePath }) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "basePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.baseUrl = baseUrl;
+        this.basePath = basePath;
+    }
+    getAssetUrl(runId, assetName) {
+        return `${this.baseUrl}${this.basePath}/${runId}/assets/${assetName}`;
+    }
+    getAssetPathTemplate() {
+        return `${this.basePath}/:runId/assets/:assetName`;
+    }
+    getEventsUrl(runId) {
+        return `${this.baseUrl}${this.basePath}/${runId}/events`;
+    }
+    getEventsPathTemplate() {
+        return `${this.basePath}/:runId/events`;
+    }
+}

package/server/fastify/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AssetStorage.cjs"), exports);
+__exportStar(require("./DefaultFlow.cjs"), exports);
+__exportStar(require("./FileSystemAssetStorage.cjs"), exports);
+__exportStar(require("./FileSystemLogger.cjs"), exports);
+__exportStar(require("./Flow.cjs"), exports);
+__exportStar(require("./FlowRun.cjs"), exports);
+__exportStar(require("./Logger.cjs"), exports);
+__exportStar(require("./modelFusionFlowPlugin.cjs"), exports);

package/server/fastify/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./AssetStorage.js";
+export * from "./DefaultFlow.js";
+export * from "./FileSystemAssetStorage.js";
+export * from "./FileSystemLogger.js";
+export * from "./Flow.js";
+export * from "./FlowRun.js";
+export * from "./Logger.js";
+export * from "./modelFusionFlowPlugin.js";

package/server/fastify/index.js

@@ -0,0 +1,8 @@
+export * from "./AssetStorage.js";
+export * from "./DefaultFlow.js";
+export * from "./FileSystemAssetStorage.js";
+export * from "./FileSystemLogger.js";
+export * from "./Flow.js";
+export * from "./FlowRun.js";
+export * from "./Logger.js";
+export * from "./modelFusionFlowPlugin.js";

package/server/fastify/modelFusionFlowPlugin.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelFusionFastifyPlugin = void 0;
+const getRun_js_1 = require("../../core/getRun.cjs");
+const FlowRun_js_1 = require("./FlowRun.cjs");
+const PathProvider_js_1 = require("./PathProvider.cjs");
+const modelFusionFastifyPlugin = async (fastify, { flow, baseUrl, basePath, assetStorage, logger, }) => {
+    const paths = new PathProvider_js_1.PathProvider({
+        baseUrl,
+        basePath,
+    });
+    const runs = {};
+    fastify.post(paths.basePath, async (request) => {
+        const run = new FlowRun_js_1.FlowRun({
+            paths,
+            assetStorage,
+            logger,
+        });
+        runs[run.runId] = run;
+        // body the request body is json, parse and validate it:
+        const input = flow.schema.input.parse(request.body);
+        // start longer-running process (no await):
+        (0, getRun_js_1.withRun)(run, async () => {
+            flow
+                .process({
+                input,
+                run,
+            })
+                .catch((error) => {
+                logger.logError({
+                    run,
+                    message: "Failed to process flow",
+                    error,
+                });
+            })
+                .finally(async () => {
+                run.finish();
+            });
+        });
+        return {
+            id: run.runId,
+            url: paths.getEventsUrl(run.runId),
+        };
+    });
+    fastify.get(paths.getAssetPathTemplate(), async (request, reply) => {
+        const runId = request.params.runId; // eslint-disable-line @typescript-eslint/no-explicit-any
+        const assetName = request.params.assetName; // eslint-disable-line @typescript-eslint/no-explicit-any
+        const asset = await assetStorage.readAsset({
+            run: runs[runId],
+            assetName,
+        });
+        if (asset == null) {
+            logger.logError({
+                run: runs[runId],
+                message: `Asset ${assetName} not found`,
+                error: new Error(`Asset ${assetName} not found`),
+            });
+            reply.status(404);
+            return { error: `Asset ${assetName} not found` };
+        }
+        const headers = {
+            "Access-Control-Allow-Origin": "*",
+            "Content-Length": asset.data.length,
+            "Content-Type": asset.contentType,
+            "Cache-Control": "no-cache",
+        };
+        reply.raw.writeHead(200, headers);
+        reply.raw.write(asset.data);
+        reply.raw.end();
+        return;
+    });
+    fastify.get(paths.getEventsPathTemplate(), async (request, reply) => {
+        const runId = request.params.runId; // eslint-disable-line @typescript-eslint/no-explicit-any
+        const eventQueue = runs[runId]?.eventQueue;
+        if (!eventQueue) {
+            return {
+                error: `No event queue found for run ID ${runId}`,
+            };
+        }
+        const headers = {
+            "Access-Control-Allow-Origin": "*",
+            "Content-Type": "text/event-stream",
+            Connection: "keep-alive",
+            "Cache-Control": "no-cache",
+            "Content-Encoding": "none",
+        };
+        reply.raw.writeHead(200, headers);
+        const textEncoder = new TextEncoder();
+        for await (const event of eventQueue) {
+            if (reply.raw.destroyed) {
+                break; // client disconnected
+            }
+            reply.raw.write(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+        }
+        if (!reply.raw.destroyed) {
+            reply.raw.write(textEncoder.encode(`data: [DONE]\n\n`));
+        }
+        reply.raw.end();
+        return;
+    });
+};
+exports.modelFusionFastifyPlugin = modelFusionFastifyPlugin;

package/server/fastify/modelFusionFlowPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { FastifyPluginAsync } from "fastify";
+import type { AssetStorage } from "./AssetStorage.js";
+import { Flow } from "./Flow.js";
+import { Logger } from "./Logger.js";
+export interface ModelFusionFastifyPluginOptions {
+    flow: Flow<any, any>;
+    baseUrl: string;
+    basePath: string;
+    assetStorage: AssetStorage;
+    logger: Logger;
+}
+export declare const modelFusionFastifyPlugin: FastifyPluginAsync<ModelFusionFastifyPluginOptions>;