modelfusion 0.53.1 → 0.54.0

package/model-function/generate-structure/streamStructure.js

@@ -1,7 +1,78 @@
 import { isDeepEqualData } from "../../util/isDeepEqualData.js";
 import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
 import { executeStreamCall } from "../executeStreamCall.js";
+/**
+ * Generate and stream an object for a prompt and a structure definition.
+ *
+ * The final object is typed according to the structure definition.
+ * The partial objects are of unknown type,
+ * but are supposed to be partial version of the final object
+ * (unless the underlying model returns invalid data).
+ *
+ * The structure definition is used as part of the final prompt.
+ *
+ * For the OpenAI chat model, this generates and parses a function call with a single function.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-structure
+ *
+ * @example
+ * const structureStream = await streamStructure(
+ *    new OpenAIChatModel({
+ *      model: "gpt-3.5-turbo",
+ *     temperature: 0,
+ *     maxCompletionTokens: 2000,
+ *   }),
+ *   new ZodStructureDefinition({
+ *     name: "generateCharacter",
+ *     description: "Generate character descriptions.",
+ *     schema: z.object({
+ *       characters: z.array(
+ *         z.object({
+ *           name: z.string(),
+ *           class: z
+ *             .string()
+ *             .describe("Character class, e.g. warrior, mage, or thief."),
+ *           description: z.string(),
+ *         })
+ *       ),
+ *     }),
+ *   }),
+ *   [
+ *     OpenAIChatMessage.user(
+ *       "Generate 3 character descriptions for a fantasy role playing game."
+ *     ),
+ *   ]
+ * );
+ *
+ * for await (const part of structureStream) {
+ *   if (!part.isComplete) {
+ *     const unknownPartialStructure = part.value;
+ *     // use your own logic to handle partial structures, e.g. with Zod .deepPartial()
+ *     // it depends on your application at which points you want to act on the partial structures
+ *   } else {
+ *     const fullyTypedStructure = part.value;
+ *     // ...
+ *   }
+ * }
+ *
+ * @param {StructureStreamingModel<PROMPT>} model - The model to use for streaming
+ * @param {StructureDefinition<NAME, STRUCTURE>} structureDefinition - The structure definition to use
+ * @param {PROMPT | ((structureDefinition: StructureDefinition<NAME, STRUCTURE>) => PROMPT)} prompt
+ * The prompt to be used.
+ * You can also pass a function that takes the structure definition as an argument and returns the prompt.
+ * @param {FunctionOptions} [options] - Optional function options
+ *
+ * @returns {AsyncIterableResultPromise<StructureStreamPart<STRUCTURE>>}
+ * The async iterable result promise.
+ * Each part of the stream is either a partial structure or the final structure.
+ * It contains a isComplete flag to indicate whether the structure is complete,
+ * and a value that is either the partial structure or the final structure.
+ */
 export function streamStructure(model, structureDefinition, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(structureDefinition)
+        : prompt;
     let lastStructure;
     let lastFullDelta;
     return new AsyncIterableResultPromise(executeStreamCall({
@@ -9,7 +80,7 @@ export function streamStructure(model, structureDefinition, prompt, options) {
         input: prompt,
         model,
         options,
-        startStream: async (options) => model.doStreamStructure(structureDefinition, prompt, options),
+        startStream: async (options) => model.doStreamStructure(structureDefinition, expandedPrompt, options),
         processDelta: (delta) => {
             const latestFullDelta = delta.fullDelta;
             const latestStructure = delta.valueDelta;

package/model-function/generate-text/generateText.cjs

@@ -4,17 +4,25 @@ exports.generateText = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 /**
- * Generates a text using a prompt.
- * The prompt format depends on the model.
- * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ * Generate text for a prompt and return it as a string.
  *
- * @example
- * const model = new OpenAICompletionModel(...);
+ * The prompt depends on the model used.
+ * For instance, OpenAI completion models expect a string prompt,
+ * whereas OpenAI chat models expect an array of chat messages.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-text
  *
+ * @example
  * const text = await generateText(
- *   model,
+ *   new OpenAICompletionModel(...),
  *   "Write a short story about a robot learning to love:\n\n"
  * );
+ *
+ * @param {TextGenerationModel<PROMPT, TextGenerationModelSettings>} model - The text generation model to use.
+ * @param {PROMPT} prompt - The prompt to use for text generation.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {ModelFunctionPromise<string>} - A promise that resolves to the generated text.
  */
 function generateText(model, prompt, options) {
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({

package/model-function/generate-text/generateText.d.ts

@@ -2,16 +2,24 @@ import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
 /**
- * Generates a text using a prompt.
- * The prompt format depends on the model.
- * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ * Generate text for a prompt and return it as a string.
  *
- * @example
- * const model = new OpenAICompletionModel(...);
+ * The prompt depends on the model used.
+ * For instance, OpenAI completion models expect a string prompt,
+ * whereas OpenAI chat models expect an array of chat messages.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-text
  *
+ * @example
  * const text = await generateText(
- *   model,
+ *   new OpenAICompletionModel(...),
  *   "Write a short story about a robot learning to love:\n\n"
  * );
+ *
+ * @param {TextGenerationModel<PROMPT, TextGenerationModelSettings>} model - The text generation model to use.
+ * @param {PROMPT} prompt - The prompt to use for text generation.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {ModelFunctionPromise<string>} - A promise that resolves to the generated text.
  */
 export declare function generateText<PROMPT>(model: TextGenerationModel<PROMPT, TextGenerationModelSettings>, prompt: PROMPT, options?: FunctionOptions): ModelFunctionPromise<string>;

package/model-function/generate-text/generateText.js

@@ -1,17 +1,25 @@
 import { executeStandardCall } from "../executeStandardCall.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 /**
- * Generates a text using a prompt.
- * The prompt format depends on the model.
- * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ * Generate text for a prompt and return it as a string.
  *
- * @example
- * const model = new OpenAICompletionModel(...);
+ * The prompt depends on the model used.
+ * For instance, OpenAI completion models expect a string prompt,
+ * whereas OpenAI chat models expect an array of chat messages.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-text
  *
+ * @example
  * const text = await generateText(
- *   model,
+ *   new OpenAICompletionModel(...),
  *   "Write a short story about a robot learning to love:\n\n"
  * );
+ *
+ * @param {TextGenerationModel<PROMPT, TextGenerationModelSettings>} model - The text generation model to use.
+ * @param {PROMPT} prompt - The prompt to use for text generation.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {ModelFunctionPromise<string>} - A promise that resolves to the generated text.
  */
 export function generateText(model, prompt, options) {
     return new ModelFunctionPromise(executeStandardCall({

package/model-function/generate-text/streamText.cjs

@@ -3,6 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamText = void 0;
 const AsyncIterableResultPromise_js_1 = require("../AsyncIterableResultPromise.cjs");
 const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
+/**
+ * Stream the generated text for a prompt as an async iterable.
+ *
+ * The prompt depends on the model used.
+ * For instance, OpenAI completion models expect a string prompt,
+ * whereas OpenAI chat models expect an array of chat messages.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-text
+ *
+ * @example
+ * const textStream = await streamText(
+ *   new OpenAICompletionModel(...),
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ *
+ * for await (const textPart of textStream) {
+ *   // ...
+ * }
+ *
+ * @param {TextStreamingModel<PROMPT>} model - The model to stream text from.
+ * @param {PROMPT} prompt - The prompt to use for text generation.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {AsyncIterableResultPromise<string>} An async iterable promise that yields the generated text.
+ */
 function streamText(model, prompt, options) {
     let accumulatedText = "";
     let lastFullDelta;

package/model-function/generate-text/streamText.d.ts

@@ -1,4 +1,29 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
 import { TextStreamingModel } from "./TextGenerationModel.js";
+/**
+ * Stream the generated text for a prompt as an async iterable.
+ *
+ * The prompt depends on the model used.
+ * For instance, OpenAI completion models expect a string prompt,
+ * whereas OpenAI chat models expect an array of chat messages.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-text
+ *
+ * @example
+ * const textStream = await streamText(
+ *   new OpenAICompletionModel(...),
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ *
+ * for await (const textPart of textStream) {
+ *   // ...
+ * }
+ *
+ * @param {TextStreamingModel<PROMPT>} model - The model to stream text from.
+ * @param {PROMPT} prompt - The prompt to use for text generation.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {AsyncIterableResultPromise<string>} An async iterable promise that yields the generated text.
+ */
 export declare function streamText<PROMPT>(model: TextStreamingModel<PROMPT>, prompt: PROMPT, options?: FunctionOptions): AsyncIterableResultPromise<string>;

package/model-function/generate-text/streamText.js

@@ -1,5 +1,30 @@
 import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
 import { executeStreamCall } from "../executeStreamCall.js";
+/**
+ * Stream the generated text for a prompt as an async iterable.
+ *
+ * The prompt depends on the model used.
+ * For instance, OpenAI completion models expect a string prompt,
+ * whereas OpenAI chat models expect an array of chat messages.
+ *
+ * @see https://modelfusion.dev/guide/function/generate-text
+ *
+ * @example
+ * const textStream = await streamText(
+ *   new OpenAICompletionModel(...),
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ *
+ * for await (const textPart of textStream) {
+ *   // ...
+ * }
+ *
+ * @param {TextStreamingModel<PROMPT>} model - The model to stream text from.
+ * @param {PROMPT} prompt - The prompt to use for text generation.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {AsyncIterableResultPromise<string>} An async iterable promise that yields the generated text.
+ */
 export function streamText(model, prompt, options) {
     let accumulatedText = "";
     let lastFullDelta;

package/model-function/generate-transcription/generateTranscription.cjs

@@ -4,18 +4,23 @@ exports.generateTranscription = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 /**
- * Transcribe audio data into text.
+ * Transcribe audio data into text. Also called speech-to-text (STT) or automatic speech recognition (ASR).
+ *
+ * @see https://modelfusion.dev/guide/function/generate-transcription
  *
  * @example
  * const data = await fs.promises.readFile("data/test.mp3");
  *
  * const transcription = await generateTranscription(
  *   new OpenAITranscriptionModel({ model: "whisper-1" }),
- *   {
- *     type: "mp3",
- *     data,
- *   }
+ *   { type: "mp3", data }
  * );
+ *
+ * @param {TranscriptionModel<DATA, TranscriptionModelSettings>} model - The model to use for transcription.
+ * @param {DATA} data - The data to transcribe.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {ModelFunctionPromise<string>} A promise that resolves to the transcribed text.
  */
 function generateTranscription(model, data, options) {
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({

package/model-function/generate-transcription/generateTranscription.d.ts

@@ -2,17 +2,22 @@ import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { TranscriptionModel, TranscriptionModelSettings } from "./TranscriptionModel.js";
 /**
- * Transcribe audio data into text.
+ * Transcribe audio data into text. Also called speech-to-text (STT) or automatic speech recognition (ASR).
+ *
+ * @see https://modelfusion.dev/guide/function/generate-transcription
  *
  * @example
  * const data = await fs.promises.readFile("data/test.mp3");
  *
  * const transcription = await generateTranscription(
  *   new OpenAITranscriptionModel({ model: "whisper-1" }),
- *   {
- *     type: "mp3",
- *     data,
- *   }
+ *   { type: "mp3", data }
  * );
+ *
+ * @param {TranscriptionModel<DATA, TranscriptionModelSettings>} model - The model to use for transcription.
+ * @param {DATA} data - The data to transcribe.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {ModelFunctionPromise<string>} A promise that resolves to the transcribed text.
  */
 export declare function generateTranscription<DATA>(model: TranscriptionModel<DATA, TranscriptionModelSettings>, data: DATA, options?: FunctionOptions): ModelFunctionPromise<string>;

package/model-function/generate-transcription/generateTranscription.js

@@ -1,18 +1,23 @@
 import { executeStandardCall } from "../executeStandardCall.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 /**
- * Transcribe audio data into text.
+ * Transcribe audio data into text. Also called speech-to-text (STT) or automatic speech recognition (ASR).
+ *
+ * @see https://modelfusion.dev/guide/function/generate-transcription
  *
  * @example
  * const data = await fs.promises.readFile("data/test.mp3");
  *
  * const transcription = await generateTranscription(
  *   new OpenAITranscriptionModel({ model: "whisper-1" }),
- *   {
- *     type: "mp3",
- *     data,
- *   }
+ *   { type: "mp3", data }
  * );
+ *
+ * @param {TranscriptionModel<DATA, TranscriptionModelSettings>} model - The model to use for transcription.
+ * @param {DATA} data - The data to transcribe.
+ * @param {FunctionOptions} [options] - Optional parameters for the function.
+ *
+ * @returns {ModelFunctionPromise<string>} A promise that resolves to the transcribed text.
  */
 export function generateTranscription(model, data, options) {
     return new ModelFunctionPromise(executeStandardCall({

package/model-function/tokenize-text/Tokenizer.d.ts

@@ -1,19 +1,43 @@
+/**
+ * Interface for a basic tokenizer capable of converting text into tokens.
+ *
+ * This serves as the base for tokenization functionalities where the focus is on the transformation of input text into a series of numeric tokens.
+ */
 export interface BasicTokenizer {
     /**
-     * Get the tokens that represent the given text.
+     * Asynchronously tokenize the given text into a sequence of numeric tokens.
+     *
+     * @param text - Input text string that needs to be tokenized.
+     * @returns A promise containing an array of numbers, where each number is a token representing a part or the whole of the input text.
      */
     tokenize: (text: string) => PromiseLike<Array<number>>;
 }
+/**
+ * Interface for a comprehensive tokenizer that extends the basic tokenization capabilities.
+ *
+ * In addition to basic tokenization, this interface provides methods for detokenization and
+ * retrieving the original text corresponding to each token, enabling a more informative and reversible transformation process.
+ */
 export interface FullTokenizer extends BasicTokenizer {
     /**
-     * Get the tokens that represent the given text and the text for each token.
+     * Asynchronously tokenize the given text, providing both the numeric tokens and their corresponding text.
+     *
+     * @param text - Input text string to be tokenized.
+     * @returns A promise containing an object with two arrays:
+     *          1. `tokens` - An array of numbers where each number is a token.
+     *          2. `tokenTexts` - An array of strings where each string represents the original text corresponding to each token.
      */
     tokenizeWithTexts: (text: string) => PromiseLike<{
         tokens: Array<number>;
         tokenTexts: Array<string>;
     }>;
     /**
-     * Get the text that represents the given tokens.
+     * Asynchronously revert a sequence of numeric tokens back into the original text.
+     * Detokenization is the process of transforming tokens back to a human-readable format, and it's essential in scenarios
+     * where the output needs to be interpretable or when the tokenization process has to be reversible.
+     *
+     * @param tokens - An array of numeric tokens to be converted back to text.
+     * @returns A promise containing a string that represents the original text corresponding to the sequence of input tokens.
      */
     detokenize: (tokens: Array<number>) => PromiseLike<string>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.53.1",
+  "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>;
+}