modelfusion 0.105.0 → 0.106.0

package/model-function/SuccessfulModelCall.cjs

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSuccessfulModelCalls = void 0;
-function extractSuccessfulModelCalls(runFunctionEvents) {
-    return runFunctionEvents.filter((event) => "model" in event &&
-        "result" in event &&
-        "status" in event.result &&
-        event.result.status === "success");
-}
-exports.extractSuccessfulModelCalls = extractSuccessfulModelCalls;

package/model-function/SuccessfulModelCall.d.ts

@@ -1,12 +0,0 @@
-import { FunctionEvent } from "../core/FunctionEvent.js";
-import { ModelCallFinishedEvent } from "./ModelCallEvent.js";
-export type SuccessfulModelCall = ModelCallFinishedEvent & {
-    result: {
-        status: "success";
-    };
-};
-export declare function extractSuccessfulModelCalls(runFunctionEvents: FunctionEvent[]): (ModelCallFinishedEvent & {
-    result: {
-        status: "success";
-    };
-})[];

package/model-function/SuccessfulModelCall.js

@@ -1,6 +0,0 @@
-export function extractSuccessfulModelCalls(runFunctionEvents) {
-    return runFunctionEvents.filter((event) => "model" in event &&
-        "result" in event &&
-        "status" in event.result &&
-        event.result.status === "success");
-}

package/model-provider/openai/OpenAICostCalculator.cjs

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAICostCalculator = void 0;
-const OpenAICompletionModel_js_1 = require("./OpenAICompletionModel.cjs");
-const OpenAIImageGenerationModel_js_1 = require("./OpenAIImageGenerationModel.cjs");
-const OpenAISpeechModel_js_1 = require("./OpenAISpeechModel.cjs");
-const OpenAITextEmbeddingModel_js_1 = require("./OpenAITextEmbeddingModel.cjs");
-const OpenAITranscriptionModel_js_1 = require("./OpenAITranscriptionModel.cjs");
-const OpenAIChatModel_js_1 = require("./OpenAIChatModel.cjs");
-class OpenAICostCalculator {
-    constructor() {
-        Object.defineProperty(this, "provider", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "openai"
-        });
-    }
-    async calculateCostInMillicents(call) {
-        const type = call.functionType;
-        const model = call.model.modelName;
-        switch (type) {
-            case "generate-image": {
-                if (model == null) {
-                    return null;
-                }
-                return (0, OpenAIImageGenerationModel_js_1.calculateOpenAIImageGenerationCostInMillicents)({
-                    model: model,
-                    settings: call.settings,
-                });
-            }
-            case "embed": {
-                if (model == null) {
-                    return null;
-                }
-                if ((0, OpenAITextEmbeddingModel_js_1.isOpenAIEmbeddingModel)(model)) {
-                    const responses = Array.isArray(call.result.response)
-                        ? call.result.response
-                        : [call.result.response];
-                    return (0, OpenAITextEmbeddingModel_js_1.calculateOpenAIEmbeddingCostInMillicents)({
-                        model,
-                        responses,
-                    });
-                }
-                break;
-            }
-            case "generate-structure":
-            case "generate-text": {
-                if (model == null) {
-                    return null;
-                }
-                if ((0, OpenAIChatModel_js_1.isOpenAIChatModel)(model)) {
-                    return (0, OpenAIChatModel_js_1.calculateOpenAIChatCostInMillicents)({
-                        model,
-                        response: call.result.response,
-                    });
-                }
-                if ((0, OpenAICompletionModel_js_1.isOpenAICompletionModel)(model)) {
-                    return (0, OpenAICompletionModel_js_1.calculateOpenAICompletionCostInMillicents)({
-                        model,
-                        response: call.result.response,
-                    });
-                }
-                break;
-            }
-            case "generate-transcription": {
-                if (model == null) {
-                    return null;
-                }
-                return (0, OpenAITranscriptionModel_js_1.calculateOpenAITranscriptionCostInMillicents)({
-                    model: model,
-                    response: call.result
-                        .response,
-                });
-            }
-            case "generate-speech": {
-                if (model == null) {
-                    return null;
-                }
-                return (0, OpenAISpeechModel_js_1.calculateOpenAISpeechCostInMillicents)({
-                    model: model,
-                    input: call.input,
-                });
-            }
-        }
-        return null;
-    }
-}
-exports.OpenAICostCalculator = OpenAICostCalculator;

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

@@ -1,6 +0,0 @@
-import { CostCalculator } from "../../cost/CostCalculator.js";
-import { SuccessfulModelCall } from "../../model-function/SuccessfulModelCall.js";
-export declare class OpenAICostCalculator implements CostCalculator {
-    readonly provider = "openai";
-    calculateCostInMillicents(call: SuccessfulModelCall): Promise<number | null>;
-}

package/model-provider/openai/OpenAICostCalculator.js

@@ -1,85 +0,0 @@
-import { calculateOpenAICompletionCostInMillicents, isOpenAICompletionModel, } from "./OpenAICompletionModel.js";
-import { calculateOpenAIImageGenerationCostInMillicents, } from "./OpenAIImageGenerationModel.js";
-import { calculateOpenAISpeechCostInMillicents, } from "./OpenAISpeechModel.js";
-import { calculateOpenAIEmbeddingCostInMillicents, isOpenAIEmbeddingModel, } from "./OpenAITextEmbeddingModel.js";
-import { calculateOpenAITranscriptionCostInMillicents, } from "./OpenAITranscriptionModel.js";
-import { calculateOpenAIChatCostInMillicents, isOpenAIChatModel, } from "./OpenAIChatModel.js";
-export class OpenAICostCalculator {
-    constructor() {
-        Object.defineProperty(this, "provider", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "openai"
-        });
-    }
-    async calculateCostInMillicents(call) {
-        const type = call.functionType;
-        const model = call.model.modelName;
-        switch (type) {
-            case "generate-image": {
-                if (model == null) {
-                    return null;
-                }
-                return calculateOpenAIImageGenerationCostInMillicents({
-                    model: model,
-                    settings: call.settings,
-                });
-            }
-            case "embed": {
-                if (model == null) {
-                    return null;
-                }
-                if (isOpenAIEmbeddingModel(model)) {
-                    const responses = Array.isArray(call.result.response)
-                        ? call.result.response
-                        : [call.result.response];
-                    return calculateOpenAIEmbeddingCostInMillicents({
-                        model,
-                        responses,
-                    });
-                }
-                break;
-            }
-            case "generate-structure":
-            case "generate-text": {
-                if (model == null) {
-                    return null;
-                }
-                if (isOpenAIChatModel(model)) {
-                    return calculateOpenAIChatCostInMillicents({
-                        model,
-                        response: call.result.response,
-                    });
-                }
-                if (isOpenAICompletionModel(model)) {
-                    return calculateOpenAICompletionCostInMillicents({
-                        model,
-                        response: call.result.response,
-                    });
-                }
-                break;
-            }
-            case "generate-transcription": {
-                if (model == null) {
-                    return null;
-                }
-                return calculateOpenAITranscriptionCostInMillicents({
-                    model: model,
-                    response: call.result
-                        .response,
-                });
-            }
-            case "generate-speech": {
-                if (model == null) {
-                    return null;
-                }
-                return calculateOpenAISpeechCostInMillicents({
-                    model: model,
-                    input: call.input,
-                });
-            }
-        }
-        return null;
-    }
-}

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/AssetStorage.js

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

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

package/server/fastify/FileSystemLogger.js

@@ -1,45 +0,0 @@
-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({ run, error, message, }) {
-        const timestamp = Date.now();
-        try {
-            const logPath = this.logPath(run);
-            await fs.mkdir(logPath, { recursive: true });
-            await fs.writeFile(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);
-        }
-    }
-}

package/server/fastify/Flow.cjs

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

package/server/fastify/Flow.d.ts

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

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

package/server/fastify/FlowRun.cjs

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

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