modelfusion 0.53.2 → 0.55.0

package/model-provider/ollama/OllamaTextGenerationModel.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
+import { parseJsonStream } from "../../util/streaming/parseJsonStream.js";
+import { OllamaApiConfiguration } from "./OllamaApiConfiguration.js";
+import { failedOllamaCallResponseHandler } from "./OllamaError.js";
+export class OllamaTextGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ollama"
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get contextWindowSize() {
+        return this.settings.contextWindowSize;
+    }
+    async callAPI(prompt, options) {
+        return callWithRetryAndThrottle({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOllamaTextGenerationAPI({
+                ...this.settings,
+                // other
+                abortSignal: options.run?.abortSignal,
+                prompt,
+                responseFormat: options.responseFormat,
+            }),
+        });
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            // "maxCompletionTokens",
+            // "stopSequences",
+            "contextWindowSize",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: OllamaTextGenerationResponseFormat.json,
+        });
+        return {
+            response,
+            text: response.response,
+        };
+    }
+    doStreamText(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: OllamaTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OllamaTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+const ollamaTextGenerationResponseSchema = z.object({
+    done: z.literal(true),
+    model: z.string(),
+    response: z.string(),
+    total_duration: z.number(),
+    load_duration: z.number(),
+    prompt_eval_count: z.number(),
+    eval_count: z.number(),
+    eval_duration: z.number(),
+    context: z.array(z.number()),
+});
+const ollamaTextStreamingResponseSchema = z.discriminatedUnion("done", [
+    z.object({
+        done: z.literal(false),
+        model: z.string(),
+        created_at: z.string(),
+        response: z.string(),
+    }),
+    z.object({
+        done: z.literal(true),
+        model: z.string(),
+        created_at: z.string(),
+        total_duration: z.number(),
+        load_duration: z.number(),
+        sample_count: z.number().optional(),
+        sample_duration: z.number().optional(),
+        prompt_eval_count: z.number(),
+        prompt_eval_duration: z.number().optional(),
+        eval_count: z.number(),
+        eval_duration: z.number(),
+        context: z.array(z.number()),
+    }),
+]);
+async function callOllamaTextGenerationAPI({ api = new OllamaApiConfiguration(), abortSignal, responseFormat, prompt, model, contextWindowSize, maxCompletionTokens, mirostat, mirostat_eta, mirostat_tau, num_gpu, num_gqa, num_threads, repeat_last_n, repeat_penalty, seed, stopSequences, temperature, tfs_z, top_k, top_p, system, template, context, }) {
+    return postJsonToApi({
+        url: api.assembleUrl(`/api/generate`),
+        headers: api.headers,
+        body: {
+            stream: responseFormat.stream,
+            model,
+            prompt,
+            options: {
+                mirostat,
+                mirostat_eta,
+                mirostat_tau,
+                num_ctx: contextWindowSize,
+                num_gpu,
+                num_gqa,
+                num_predict: maxCompletionTokens,
+                num_threads,
+                repeat_last_n,
+                repeat_penalty,
+                seed,
+                stop: stopSequences,
+                temperature,
+                tfs_z,
+                top_k,
+                top_p,
+            },
+            system,
+            template,
+            context,
+        },
+        failedResponseHandler: failedOllamaCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+async function createOllamaFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue();
+    let accumulatedText = "";
+    // process the stream asynchonously (no 'await' on purpose):
+    parseJsonStream({
+        stream,
+        schema: ollamaTextStreamingResponseSchema,
+        process(event) {
+            if (event.done === true) {
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content: accumulatedText,
+                        isComplete: true,
+                        delta: "",
+                    },
+                    valueDelta: "",
+                });
+            }
+            else {
+                accumulatedText += event.response;
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content: accumulatedText,
+                        isComplete: false,
+                        delta: event.response,
+                    },
+                    valueDelta: event.response,
+                });
+            }
+        },
+        onDone() {
+            queue.close();
+        },
+    });
+    return queue;
+}
+export const OllamaTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(ollamaTextGenerationResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createOllamaFullDeltaIterableQueue(response.body),
+    },
+};

package/model-provider/ollama/index.cjs

@@ -0,0 +1,21 @@
+"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 });
+exports.OllamaError = void 0;
+__exportStar(require("./OllamaApiConfiguration.cjs"), exports);
+var OllamaError_js_1 = require("./OllamaError.cjs");
+Object.defineProperty(exports, "OllamaError", { enumerable: true, get: function () { return OllamaError_js_1.OllamaError; } });
+__exportStar(require("./OllamaTextGenerationModel.cjs"), exports);

package/model-provider/ollama/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./OllamaApiConfiguration.js";
+export { OllamaError, OllamaErrorData } from "./OllamaError.js";
+export * from "./OllamaTextGenerationModel.js";

package/model-provider/ollama/index.js

@@ -0,0 +1,3 @@
+export * from "./OllamaApiConfiguration.js";
+export { OllamaError } from "./OllamaError.js";
+export * from "./OllamaTextGenerationModel.js";

package/model-provider/openai/OpenAICompletionModel.cjs

@@ -4,13 +4,13 @@ exports.OpenAITextResponseFormat = exports.OpenAICompletionModel = exports.calcu
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
-const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");
 const TextPromptFormat_js_1 = require("../../model-function/generate-text/TextPromptFormat.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const parseJSON_js_1 = require("../../util/parseJSON.cjs");
+const parseEventSourceStream_js_1 = require("../../util/streaming/parseEventSourceStream.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");

package/model-provider/openai/OpenAICompletionModel.js

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { AsyncQueue } from "../../util/AsyncQueue.js";
-import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
 import { mapChatPromptToTextFormat, mapInstructionPromptToTextFormat, } from "../../model-function/generate-text/TextPromptFormat.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseJsonWithZod } from "../../util/parseJSON.js";
+import { parseEventSourceStream } from "../../util/streaming/parseEventSourceStream.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";

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

@@ -3,7 +3,7 @@ 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("../../../event-source/parseEventSourceStream.cjs");
+const parseEventSourceStream_js_1 = require("../../../util/streaming/parseEventSourceStream.cjs");
 const parseJSON_js_1 = require("../../../util/parseJSON.cjs");
 const chatResponseStreamEventSchema = zod_1.z.object({
     choices: zod_1.z.array(zod_1.z.object({

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AsyncQueue } from "../../../util/AsyncQueue.js";
-import { parseEventSourceStream } from "../../../event-source/parseEventSourceStream.js";
+import { parseEventSourceStream } from "../../../util/streaming/parseEventSourceStream.js";
 import { safeParseJsonWithZod } from "../../../util/parseJSON.js";
 const chatResponseStreamEventSchema = z.object({
     choices: z.array(z.object({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.53.2",
+  "version": "0.55.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -38,6 +38,16 @@
       "types": "./index.d.ts",
       "import": "./index.js",
       "require": "./index.cjs"
+    },
+    "./browser": {
+      "types": "./browser/index.d.ts",
+      "import": "./browser/index.js",
+      "require": "./browser/index.cjs"
+    },
+    "./fastify-server": {
+      "types": "./server/fastify/index.d.ts",
+      "import": "./server/fastify/index.js",
+      "require": "./server/fastify/index.cjs"
     }
   },
   "scripts": {
@@ -62,8 +72,6 @@
     "zod-to-json-schema": "3.21.4"
   },
   "devDependencies": {
-    "@tsconfig/recommended": "1.0.3",
-    "@types/deep-equal": "^1.0.2",
     "@types/node": "18.11.9",
     "@types/ws": "^8.5.7",
     "@typescript-eslint/eslint-plugin": "^6.1.0",
@@ -71,8 +79,9 @@
     "copyfiles": "2.4.1",
     "eslint": "^8.45.0",
     "eslint-config-prettier": "9.0.0",
+    "fastify": "^4.0.0",
     "husky": "^8.0.3",
-    "lint-staged": "14.0.1",
+    "lint-staged": "15.0.2",
     "prettier": "3.0.3",
     "rimraf": "5.0.5",
     "typescript": "5.2.2",

package/server/fastify/AssetStorage.cjs

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

package/server/fastify/AssetStorage.d.ts

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

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

package/server/fastify/DefaultFlow.cjs

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

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

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

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

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

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