modelfusion 0.53.2 → 0.54.0

package/README.md

@@ -623,9 +623,9 @@ Create an 19th century painting image for your input.
 
 Record audio with push-to-talk and transcribe it using Whisper, implemented as a Next.js app. The app shows a list of the transcriptions.
 
-### [Speech Streaming (Vite(React) + Fastify))](https://github.com/lgrammel/modelfusion/tree/main/examples/speech-streaming-vite-react-fastify)
+### [Duplex Speech Streaming (using Vite/React & ModelFusion Server/Fastify)](https://github.com/lgrammel/modelfusion/tree/main/examples/speech-streaming-vite-react-fastify)
 
-> _Speech Streaming_, _OpenAI_, _Elevenlabs_ _streaming_, _Vite_, _Fastify_
+> _Speech Streaming_, _OpenAI_, _Elevenlabs_ _streaming_, _Vite_, _Fastify_, _ModelFusion Server_
 
 Given a prompt, the server returns both a text and a speech stream response.
 

package/browser/convertAudioChunksToBase64.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAudioChunksToBase64 = void 0;
+const convertBlobToBase64_js_1 = require("./convertBlobToBase64.cjs");
+function convertAudioChunksToBase64({ audioChunks, mimeType, }) {
+    return (0, convertBlobToBase64_js_1.convertBlobToBase64)(new Blob(audioChunks, { type: mimeType }));
+}
+exports.convertAudioChunksToBase64 = convertAudioChunksToBase64;

package/browser/convertAudioChunksToBase64.d.ts

@@ -0,0 +1,4 @@
+export declare function convertAudioChunksToBase64({ audioChunks, mimeType, }: {
+    audioChunks: Blob[];
+    mimeType: string;
+}): Promise<string>;

package/browser/convertAudioChunksToBase64.js

@@ -0,0 +1,4 @@
+import { convertBlobToBase64 } from "./convertBlobToBase64.js";
+export function convertAudioChunksToBase64({ audioChunks, mimeType, }) {
+    return convertBlobToBase64(new Blob(audioChunks, { type: mimeType }));
+}

package/browser/convertBlobToBase64.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBlobToBase64 = void 0;
+async function convertBlobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            if (reader.result) {
+                const base64String = btoa(new Uint8Array(reader.result).reduce((data, byte) => data + String.fromCharCode(byte), ""));
+                resolve(base64String);
+            }
+            else {
+                reject(new Error("Failed to read blob."));
+            }
+        };
+        reader.onerror = () => {
+            reader.abort();
+            reject(new DOMException("Problem parsing input blob."));
+        };
+        reader.readAsArrayBuffer(blob);
+    });
+}
+exports.convertBlobToBase64 = convertBlobToBase64;

package/browser/convertBlobToBase64.d.ts

@@ -0,0 +1 @@
+export declare function convertBlobToBase64(blob: Blob): Promise<string>;

package/browser/convertBlobToBase64.js

@@ -0,0 +1,19 @@
+export async function convertBlobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            if (reader.result) {
+                const base64String = btoa(new Uint8Array(reader.result).reduce((data, byte) => data + String.fromCharCode(byte), ""));
+                resolve(base64String);
+            }
+            else {
+                reject(new Error("Failed to read blob."));
+            }
+        };
+        reader.onerror = () => {
+            reader.abort();
+            reject(new DOMException("Problem parsing input blob."));
+        };
+        reader.readAsArrayBuffer(blob);
+    });
+}

package/{ui → browser}/index.cjs

@@ -15,3 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./MediaSourceAppender.cjs"), exports);
+__exportStar(require("./convertAudioChunksToBase64.cjs"), exports);
+__exportStar(require("./convertBlobToBase64.cjs"), exports);
+__exportStar(require("./invokeFlow.cjs"), exports);
+__exportStar(require("./readEventSource.cjs"), exports);
+__exportStar(require("./readEventSourceStream.cjs"), exports);

package/browser/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./MediaSourceAppender.js";
+export * from "./convertAudioChunksToBase64.js";
+export * from "./convertBlobToBase64.js";
+export * from "./invokeFlow.js";
+export * from "./readEventSource.js";
+export * from "./readEventSourceStream.js";

package/browser/index.js

@@ -0,0 +1,6 @@
+export * from "./MediaSourceAppender.js";
+export * from "./convertAudioChunksToBase64.js";
+export * from "./convertBlobToBase64.js";
+export * from "./invokeFlow.js";
+export * from "./readEventSource.js";
+export * from "./readEventSourceStream.js";

package/browser/invokeFlow.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeFlow = void 0;
+const ZodSchema_1 = require("../core/structure/ZodSchema");
+const readEventSource_1 = require("./readEventSource");
+async function invokeFlow({ url, input, schema, onEvent, onStop, }) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input),
+    });
+    const eventSourceUrl = (await response.json()).url;
+    (0, readEventSource_1.readEventSource)({
+        url: eventSourceUrl,
+        schema: new ZodSchema_1.ZodSchema(schema.events),
+        isStopEvent(event) {
+            return event.data === "[DONE]";
+        },
+        onEvent,
+        onStop,
+    });
+}
+exports.invokeFlow = invokeFlow;

package/browser/invokeFlow.d.ts

@@ -0,0 +1,8 @@
+import { FlowSchema } from "../server/fastify/FlowSchema";
+export declare function invokeFlow<INPUT, EVENT>({ url, input, schema, onEvent, onStop, }: {
+    url: string;
+    input: INPUT;
+    schema: FlowSchema<INPUT, EVENT>;
+    onEvent: (event: EVENT, eventSource: EventSource) => void;
+    onStop?: (eventSource: EventSource) => void;
+}): Promise<void>;

package/browser/invokeFlow.js

@@ -0,0 +1,19 @@
+import { ZodSchema } from "../core/structure/ZodSchema";
+import { readEventSource } from "./readEventSource";
+export async function invokeFlow({ url, input, schema, onEvent, onStop, }) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input),
+    });
+    const eventSourceUrl = (await response.json()).url;
+    readEventSource({
+        url: eventSourceUrl,
+        schema: new ZodSchema(schema.events),
+        isStopEvent(event) {
+            return event.data === "[DONE]";
+        },
+        onEvent,
+        onStop,
+    });
+}

package/{event-source → browser}/readEventSource.cjs

@@ -2,11 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEventSource = void 0;
 const parseJSON_js_1 = require("../util/parseJSON.cjs");
-function readEventSource({ url, schema, onEvent, onError = console.error, }) {
+function readEventSource({ url, schema, onEvent, onError = console.error, onStop, isStopEvent, }) {
     const eventSource = new EventSource(url);
-    eventSource.onmessage = (e) => {
+    eventSource.onmessage = (event) => {
         try {
-            const parseResult = (0, parseJSON_js_1.safeParseJsonWithSchema)(e.data, schema);
+            if (isStopEvent?.(event)) {
+                eventSource.close();
+                onStop?.(eventSource);
+                return;
+            }
+            const parseResult = (0, parseJSON_js_1.safeParseJsonWithSchema)(event.data, schema);
             if (!parseResult.success) {
                 onError(parseResult.error, eventSource);
                 return;

package/{event-source → browser}/readEventSource.d.ts

@@ -1,7 +1,9 @@
 import { Schema } from "../core/structure/Schema.js";
-export declare function readEventSource<T>({ url, schema, onEvent, onError, }: {
+export declare function readEventSource<T>({ url, schema, onEvent, onError, onStop, isStopEvent, }: {
     url: string;
     schema: Schema<T>;
     onEvent: (event: T, eventSource: EventSource) => void;
     onError?: (error: unknown, eventSource: EventSource) => void;
+    onStop?: (eventSource: EventSource) => void;
+    isStopEvent?: (event: MessageEvent<unknown>) => boolean;
 }): void;

package/{event-source → browser}/readEventSource.js

@@ -1,9 +1,14 @@
 import { safeParseJsonWithSchema } from "../util/parseJSON.js";
-export function readEventSource({ url, schema, onEvent, onError = console.error, }) {
+export function readEventSource({ url, schema, onEvent, onError = console.error, onStop, isStopEvent, }) {
     const eventSource = new EventSource(url);
-    eventSource.onmessage = (e) => {
+    eventSource.onmessage = (event) => {
         try {
-            const parseResult = safeParseJsonWithSchema(e.data, schema);
+            if (isStopEvent?.(event)) {
+                eventSource.close();
+                onStop?.(eventSource);
+                return;
+            }
+            const parseResult = safeParseJsonWithSchema(event.data, schema);
             if (!parseResult.success) {
                 onError(parseResult.error, eventSource);
                 return;

package/{event-source → browser}/readEventSourceStream.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEventSourceStream = void 0;
 const parseJSON_js_1 = require("../util/parseJSON.cjs");
 const AsyncQueue_js_1 = require("../util/AsyncQueue.cjs");
-const parseEventSourceStream_js_1 = require("./parseEventSourceStream.cjs");
+const parseEventSourceStream_js_1 = require("../event-source/parseEventSourceStream.cjs");
 function readEventSourceStream({ stream, schema, errorHandler, }) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     // run async (no await on purpose):

package/{event-source → browser}/readEventSourceStream.js

@@ -1,6 +1,6 @@
 import { safeParseJsonWithSchema } from "../util/parseJSON.js";
 import { AsyncQueue } from "../util/AsyncQueue.js";
-import { parseEventSourceStream } from "./parseEventSourceStream.js";
+import { parseEventSourceStream } from "../event-source/parseEventSourceStream.js";
 export function readEventSourceStream({ stream, schema, errorHandler, }) {
     const queue = new AsyncQueue();
     // run async (no await on purpose):

package/event-source/createEventSourceStream.cjs

@@ -5,10 +5,14 @@ const textEncoder = new TextEncoder();
 function createEventSourceStream(events) {
     return new ReadableStream({
         async start(controller) {
-            for await (const event of events) {
-                controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+            try {
+                for await (const event of events) {
+                    controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+                }
+            }
+            finally {
+                controller.close();
             }
-            controller.close();
         },
     });
 }

package/event-source/createEventSourceStream.js

@@ -2,10 +2,14 @@ const textEncoder = new TextEncoder();
 export function createEventSourceStream(events) {
     return new ReadableStream({
         async start(controller) {
-            for await (const event of events) {
-                controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+            try {
+                for await (const event of events) {
+                    controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+                }
+            }
+            finally {
+                controller.close();
             }
-            controller.close();
         },
     });
 }

package/event-source/index.cjs

@@ -15,5 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./createEventSourceStream.cjs"), exports);
-__exportStar(require("./readEventSource.cjs"), exports);
-__exportStar(require("./readEventSourceStream.cjs"), exports);

package/event-source/index.d.ts

@@ -1,3 +1 @@
 export * from "./createEventSourceStream.js";
-export * from "./readEventSource.js";
-export * from "./readEventSourceStream.js";

package/event-source/index.js

@@ -1,3 +1 @@
 export * from "./createEventSourceStream.js";
-export * from "./readEventSource.js";
-export * from "./readEventSourceStream.js";

package/index.cjs

@@ -25,6 +25,5 @@ __exportStar(require("./observability/index.cjs"), exports);
 __exportStar(require("./retriever/index.cjs"), exports);
 __exportStar(require("./text-chunk/index.cjs"), exports);
 __exportStar(require("./tool/index.cjs"), exports);
-__exportStar(require("./ui/index.cjs"), exports);
 __exportStar(require("./util/index.cjs"), exports);
 __exportStar(require("./vector-index/index.cjs"), exports);

package/index.d.ts

@@ -9,6 +9,5 @@ export * from "./observability/index.js";
 export * from "./retriever/index.js";
 export * from "./text-chunk/index.js";
 export * from "./tool/index.js";
-export * from "./ui/index.js";
 export * from "./util/index.js";
 export * from "./vector-index/index.js";

package/index.js

@@ -9,6 +9,5 @@ export * from "./observability/index.js";
 export * from "./retriever/index.js";
 export * from "./text-chunk/index.js";
 export * from "./tool/index.js";
-export * from "./ui/index.js";
 export * from "./util/index.js";
 export * from "./vector-index/index.js";

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.54.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>;
+}