modelfusion 0.48.0 → 0.49.0

package/README.md

@@ -35,17 +35,17 @@ Or use a template: [ModelFusion terminal app starter](https://github.com/lgramme
 
 You can provide API keys for the different [integrations](https://modelfusion.dev/integration/model-provider/) using environment variables (e.g., `OPENAI_API_KEY`) or pass them into the model constructors as options.
 
-### [Generate and Stream Text](https://modelfusion.dev/guide/function/generate-text)
+### [Generate Text](https://modelfusion.dev/guide/function/generate-text)
 
 Generate text using a language model and a prompt.
 You can stream the text if it is supported by the model.
-You can use [prompt formats](https://modelfusion.dev/guide/function/generate-text/prompt-format) to change the prompt format of a model.
+You can use [prompt formats](https://modelfusion.dev/guide/function/generate-text#prompt-format) to change the prompt format of a model.
 
 #### generateText
 
 ```ts
 const text = await generateText(
-  new OpenAITextGenerationModel({
+  new OpenAICompletionModel({
     model: "gpt-3.5-turbo-instruct",
   }),
   "Write a short story about a robot learning to love:\n\n"
@@ -58,7 +58,7 @@ Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai),
 
 ```ts
 const textStream = await streamText(
-  new OpenAITextGenerationModel({
+  new OpenAICompletionModel({
     model: "gpt-3.5-turbo-instruct",
   }),
   "Write a short story about a robot learning to love:\n\n"
@@ -71,7 +71,7 @@ for await (const textFragment of textStream) {
 
 Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Anthropic](https://modelfusion.dev/integration/model-provider/anthropic), [Cohere](https://modelfusion.dev/integration/model-provider/cohere), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp)
 
-### [Generate and Stream Structure](https://modelfusion.dev/guide/function/generate-structure#generatestructure)
+### [Generate Structure](https://modelfusion.dev/guide/function/generate-structure#generatestructure)
 
 Generate typed objects using a language model and a schema.
 
@@ -256,12 +256,12 @@ const { tool, parameters, result, text } = await useToolOrGenerateText(
 );
 ```
 
-### [Transcribe Speech](https://modelfusion.dev/guide/function/transcribe-speech)
+### [Generate Transcription](https://modelfusion.dev/guide/function/generate-transcription)
 
-Turn speech (audio) into text.
+Transcribe speech (audio) data into text. Also called speech-to-text (STT).
 
 ```ts
-const transcription = await transcribe(
+const transcription = await generateTranscription(
   new OpenAITranscriptionModel({ model: "whisper-1" }),
   {
     type: "mp3",
@@ -272,18 +272,20 @@ const transcription = await transcribe(
 
 Providers: [OpenAI (Whisper)](https://modelfusion.dev/integration/model-provider/openai)
 
-### [Synthesize Speech](https://modelfusion.dev/guide/function/synthesize-speech)
+### [Generate Speech](https://modelfusion.dev/guide/function/generate-speech)
 
-Generate speech (audio) from text. Also called TTS (text-to-speech).
+Synthesize speech (audio) from text. Also called TTS (text-to-speech).
 
 Providers: [Eleven Labs](https://modelfusion.dev/integration/model-provider/elevenlabs), [LMNT](https://modelfusion.dev/integration/model-provider/lmnt)
 
-#### Standard mode
+#### generateSpeech
+
+`generateSpeech` synthesizes speech from text.
 
 ```ts
 // `speech` is a Buffer with MP3 audio data
-const speech = await synthesizeSpeech(
-  new LmntSpeechSynthesisModel({
+const speech = await generateSpeech(
+  new LmntSpeechModel({
     voice: "034b632b-df71-46c8-b440-86a42ffc3cf3", // Henry
   }),
   "Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
@@ -293,13 +295,15 @@ const speech = await synthesizeSpeech(
 );
 ```
 
-#### Duplex streaming mode
+#### streamSpeech
+
+`generateSpeech` generates a stream of speech chunks from text or from a text stream. Depending on the model, this can be fully duplex.
 
 ```ts
 const textStream = await streamText(/* ... */);
 
-const speechStream = await synthesizeSpeech(
-  new ElevenLabsSpeechSynthesisModel({
+const speechStream = await streamSpeech(
+  new ElevenLabsSpeechModel({
     voice: "pNInz6obpgDQGcFmaJgB", // Adam
     model: "eleven_monolingual_v1",
     voiceSettings: { stability: 1, similarityBoost: 0.35 },
@@ -307,8 +311,7 @@ const speechStream = await synthesizeSpeech(
       chunkLengthSchedule: [50, 90, 120, 150, 200],
     },
   }),
-  textStream,
-  { mode: "stream-duplex" }
+  textStream
 );
 
 for await (const part of speechStream) {
@@ -316,21 +319,6 @@ for await (const part of speechStream) {
 }
 ```
 
-### [Describe Image](https://modelfusion.dev/guide/function/describe-image)
-
-Describe an image as text, e.g. for image captioning or OCR.
-
-```ts
-const text = await describeImage(
-  new HuggingFaceImageDescriptionModel({
-    model: "nlpconnect/vit-gpt2-image-captioning",
-  }),
-  data // buffer with image data
-);
-```
-
-Providers: [HuggingFace](/integration/model-provider/huggingface)
-
 ### [Generate Image](https://modelfusion.dev/guide/function/generate-image)
 
 Generate an image from a prompt.
@@ -460,7 +448,7 @@ Available Vector Stores: [Memory](https://modelfusion.dev/integration/vector-ind
 
 Prompt formats let you use higher level prompt structures (such as instruction or chat prompts) for different models.
 
-#### [Text Generation Prompt Formats](https://modelfusion.dev/guide/function/generate-text/prompt-format)
+#### [Text Generation Prompt Formats](https://modelfusion.dev/guide/function/generate-text#prompt-format)
 
 ```ts
 const text = await generateText(
@@ -525,7 +513,7 @@ ModelFusion model functions return rich results that include the original respon
 ```ts
 // access the full response (needs to be typed) and the metadata:
 const { value, response, metadata } = await generateText(
-  new OpenAITextGenerationModel({
+  new OpenAICompletionModel({
     model: "gpt-3.5-turbo-instruct",
     maxCompletionTokens: 1000,
     n: 2, // generate 2 completions
@@ -536,7 +524,7 @@ const { value, response, metadata } = await generateText(
 console.log(metadata);
 
 // cast to the response type:
-for (const choice of (response as OpenAITextGenerationResponse).choices) {
+for (const choice of (response as OpenAICompletionResponse).choices) {
   console.log(choice.text);
 }
 ```
@@ -550,17 +538,14 @@ Integrations: [Helicone](https://modelfusion.dev/integration/observability/helic
 ### [Guide](https://modelfusion.dev/guide)
 
 - [Model Functions](https://modelfusion.dev/guide/function/)
-  - [Generate and stream text](https://modelfusion.dev/guide/function/generate-text)
-    - [Prompt Format](https://modelfusion.dev/guide/function/generate-text/prompt-format)
-  - [Generate and stream structure](https://modelfusion.dev/guide/function/generate-structure)
+  - [Generate text](https://modelfusion.dev/guide/function/generate-text)
+  - [Generate image](https://modelfusion.dev/guide/function/generate-image)
+  - [Generate speech](https://modelfusion.dev/guide/function/generate-speech)
+  - [Generate transcription](https://modelfusion.dev/guide/function/generation-transcription)
+  - [Generate structure](https://modelfusion.dev/guide/function/generate-structure)
   - [Generate structure or text](https://modelfusion.dev/guide/function/generate-structure-or-text)
   - [Tokenize Text](https://modelfusion.dev/guide/function/tokenize-text)
   - [Embed Value](https://modelfusion.dev/guide/function/embed)
-  - [Transcribe Speech](https://modelfusion.dev/guide/function/transcribe-speech)
-  - [Synthesize Speech](https://modelfusion.dev/guide/function/synthesize-speech)
-  - [Describe Image](https://modelfusion.dev/guide/function/describe-image)
-  - [Generate Image](https://modelfusion.dev/guide/function/generate-image)
-    - [Prompt Format](https://modelfusion.dev/guide/function/generate-image/prompt-format)
 - [Guards](https://modelfusion.dev/guide/guard)
 - [Tools](https://modelfusion.dev/guide/tools)
 - [Vector Indices](https://modelfusion.dev/guide/vector-index)
@@ -628,7 +613,7 @@ 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.
 
-### [Duplex Speech Streaming (Vite(React) + Fastify))](https://github.com/lgrammel/modelfusion/tree/main/examples/duplex-speech-streaming-vite-react-fastify)
+### [Speech Streaming (Vite(React) + Fastify))](https://github.com/lgrammel/modelfusion/tree/main/examples/speech-streaming-vite-react-fastify)
 
 > _Speech Streaming_, _OpenAI_, _Elevenlabs_ _streaming_, _Vite_, _Fastify_
 

package/model-function/AsyncIterableResultPromise.cjs

@@ -13,25 +13,25 @@ class AsyncIterableResultPromise extends Promise {
             writable: true,
             value: fullPromise
         });
-        Object.defineProperty(this, "outputPromise", {
+        Object.defineProperty(this, "valuePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.outputPromise = fullPromise.then((result) => result.output);
+        this.valuePromise = fullPromise.then((result) => result.value);
     }
     asFullResponse() {
         return this.fullPromise;
     }
     then(onfulfilled, onrejected) {
-        return this.outputPromise.then(onfulfilled, onrejected);
+        return this.valuePromise.then(onfulfilled, onrejected);
     }
     catch(onrejected) {
-        return this.outputPromise.catch(onrejected);
+        return this.valuePromise.catch(onrejected);
     }
     finally(onfinally) {
-        return this.outputPromise.finally(onfinally);
+        return this.valuePromise.finally(onfinally);
     }
 }
 exports.AsyncIterableResultPromise = AsyncIterableResultPromise;

package/model-function/AsyncIterableResultPromise.d.ts

@@ -1,13 +1,13 @@
 import { ModelCallMetadata } from "./ModelCallMetadata.js";
 export declare class AsyncIterableResultPromise<T> extends Promise<AsyncIterable<T>> {
     private fullPromise;
-    private outputPromise;
+    private valuePromise;
     constructor(fullPromise: Promise<{
-        output: AsyncIterable<T>;
+        value: AsyncIterable<T>;
         metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
     }>);
     asFullResponse(): Promise<{
-        output: AsyncIterable<T>;
+        value: AsyncIterable<T>;
         metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
     }>;
     then<TResult1 = AsyncIterable<T>, TResult2 = never>(onfulfilled?: ((value: AsyncIterable<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

package/model-function/AsyncIterableResultPromise.js

@@ -10,24 +10,24 @@ export class AsyncIterableResultPromise extends Promise {
             writable: true,
             value: fullPromise
         });
-        Object.defineProperty(this, "outputPromise", {
+        Object.defineProperty(this, "valuePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.outputPromise = fullPromise.then((result) => result.output);
+        this.valuePromise = fullPromise.then((result) => result.value);
     }
     asFullResponse() {
         return this.fullPromise;
     }
     then(onfulfilled, onrejected) {
-        return this.outputPromise.then(onfulfilled, onrejected);
+        return this.valuePromise.then(onfulfilled, onrejected);
     }
     catch(onrejected) {
-        return this.outputPromise.catch(onrejected);
+        return this.valuePromise.catch(onrejected);
     }
     finally(onfinally) {
-        return this.outputPromise.finally(onfinally);
+        return this.valuePromise.finally(onfinally);
     }
 }

package/model-function/Model.d.ts

@@ -18,7 +18,7 @@ export interface Model<SETTINGS extends ModelSettings> {
      * The `withSettings` method creates a new model with the same configuration as the original model, but with the specified settings changed.
      *
      * @example
-     * const model = new OpenAITextGenerationModel({
+     * const model = new OpenAICompletionModel({
      *   model: "gpt-3.5-turbo-instruct",
      *   maxCompletionTokens: 500,
      * });

package/model-function/ModelCallEvent.d.ts

@@ -1,14 +1,12 @@
 import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
 import { ModelInformation } from "./ModelInformation.js";
-import { ImageDescriptionFinishedEvent, ImageDescriptionStartedEvent } from "./describe-image/ImageDescriptionEvent.js";
 import { EmbeddingFinishedEvent, EmbeddingStartedEvent } from "./embed/EmbeddingEvent.js";
 import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
+import { SpeechGenerationFinishedEvent, SpeechGenerationStartedEvent, SpeechStreamingFinishedEvent, SpeechStreamingStartedEvent } from "./generate-speech/SpeechGenerationEvent.js";
 import { StructureGenerationFinishedEvent, StructureGenerationStartedEvent } from "./generate-structure/StructureGenerationEvent.js";
 import { StructureStreamingFinishedEvent, StructureStreamingStartedEvent } from "./generate-structure/StructureStreamingEvent.js";
-import { TextGenerationFinishedEvent, TextGenerationStartedEvent } from "./generate-text/TextGenerationEvent.js";
-import { TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextStreamingEvent.js";
-import { SpeechSynthesisFinishedEvent, SpeechSynthesisStartedEvent } from "./synthesize-speech/SpeechSynthesisEvent.js";
-import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./transcribe-speech/TranscriptionEvent.js";
+import { TextGenerationFinishedEvent, TextGenerationStartedEvent, TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextGenerationEvent.js";
+import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./generate-transcription/TranscriptionEvent.js";
 export interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
     model: ModelInformation;
     /**
@@ -49,5 +47,5 @@ export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
      */
     result: BaseModelCallFinishedEventResult;
 }
-export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageDescriptionStartedEvent | ImageGenerationStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | SpeechSynthesisStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageDescriptionFinishedEvent | ImageGenerationFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | SpeechSynthesisFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;
+export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
+export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;

package/model-function/embed/embed.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.embed = exports.embedMany = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 /**
  * Generate embeddings for multiple values.
@@ -16,7 +16,7 @@ const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
  * );
  */
 function embedMany(model, values, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "embedding",
         input: values,
         model,
@@ -57,7 +57,7 @@ exports.embedMany = embedMany;
  * );
  */
 function embed(model, value, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "embedding",
         input: value,
         model,

package/model-function/embed/embed.js

@@ -1,4 +1,4 @@
-import { executeCall } from "../executeCall.js";
+import { executeStandardCall } from "../executeStandardCall.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 /**
  * Generate embeddings for multiple values.
@@ -13,7 +13,7 @@ import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
  * );
  */
 export function embedMany(model, values, options) {
-    return new ModelFunctionPromise(executeCall({
+    return new ModelFunctionPromise(executeStandardCall({
         functionType: "embedding",
         input: values,
         model,
@@ -53,7 +53,7 @@ export function embedMany(model, values, options) {
  * );
  */
 export function embed(model, value, options) {
-    return new ModelFunctionPromise(executeCall({
+    return new ModelFunctionPromise(executeStandardCall({
         functionType: "embedding",
         input: value,
         model,

package/model-function/{executeCall.cjs → executeStandardCall.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeCall = void 0;
+exports.executeStandardCall = void 0;
 const nanoid_1 = require("nanoid");
 const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
 const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
@@ -10,7 +10,7 @@ const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
 const getRun_js_1 = require("../core/getRun.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
-async function executeCall({ model, options, input, functionType, generateResponse, }) {
+async function executeStandardCall({ model, options, input, functionType, generateResponse, }) {
     const run = await (0, getRun_js_1.getRun)(options?.run);
     const settings = model.settings;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
@@ -104,4 +104,4 @@ async function executeCall({ model, options, input, functionType, generateRespon
         },
     };
 }
-exports.executeCall = executeCall;
+exports.executeStandardCall = executeStandardCall;

package/model-function/{executeCall.d.ts → executeStandardCall.d.ts}

@@ -2,7 +2,7 @@ import { FunctionOptions } from "../core/FunctionOptions.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
 import { ModelCallMetadata } from "./ModelCallMetadata.js";
-export declare function executeCall<VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, generateResponse, }: {
+export declare function executeStandardCall<VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, generateResponse, }: {
     model: MODEL;
     options?: FunctionOptions;
     input: unknown;

package/model-function/{executeCall.js → executeStandardCall.js}

@@ -7,7 +7,7 @@ import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
 import { getRun } from "../core/getRun.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { runSafe } from "../util/runSafe.js";
-export async function executeCall({ model, options, input, functionType, generateResponse, }) {
+export async function executeStandardCall({ model, options, input, functionType, generateResponse, }) {
     const run = await getRun(options?.run);
     const settings = model.settings;
     const eventSource = new FunctionEventSource({

package/model-function/executeStreamCall.cjs

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeStreamCall = void 0;
+const nanoid_1 = require("nanoid");
+const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
+const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
+const AbortError_js_1 = require("../core/api/AbortError.cjs");
+const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
+const getRun_js_1 = require("../core/getRun.cjs");
+const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
+const runSafe_js_1 = require("../util/runSafe.cjs");
+async function executeStreamCall({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }) {
+    const run = await (0, getRun_js_1.getRun)(options?.run);
+    const settings = model.settings;
+    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
+        observers: [
+            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
+            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
+            ...(settings.observers ?? []),
+            ...(run?.functionObserver != null ? [run.functionObserver] : []),
+            ...(options?.observers ?? []),
+        ],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
+    const startMetadata = {
+        functionType,
+        callId: `call-${(0, nanoid_1.nanoid)()}`,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        model: model.modelInformation,
+        settings: model.settingsForEvent,
+        input,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
+    };
+    eventSource.notify({
+        eventType: "started",
+        ...startMetadata,
+    });
+    const result = await (0, runSafe_js_1.runSafe)(async () => {
+        const deltaIterable = await startStream({
+            functionId: options?.functionId,
+            logging: options?.logging,
+            observers: options?.observers,
+            run,
+        });
+        return (async function* () {
+            for await (const event of deltaIterable) {
+                if (event?.type === "error") {
+                    const error = event.error;
+                    const finishMetadata = {
+                        eventType: "finished",
+                        ...startMetadata,
+                        finishTimestamp: new Date(),
+                        durationInMs: durationMeasurement.durationInMs,
+                    };
+                    eventSource.notify(error instanceof AbortError_js_1.AbortError
+                        ? {
+                            ...finishMetadata,
+                            result: { status: "abort" },
+                        }
+                        : {
+                            ...finishMetadata,
+                            result: { status: "error", error },
+                        });
+                    throw error;
+                }
+                if (event?.type === "delta") {
+                    const value = processDelta(event);
+                    if (value !== undefined) {
+                        yield value;
+                    }
+                }
+            }
+            if (processFinished != null) {
+                const value = processFinished();
+                if (value !== undefined) {
+                    yield value;
+                }
+            }
+            const finishMetadata = {
+                eventType: "finished",
+                ...startMetadata,
+                finishTimestamp: new Date(),
+                durationInMs: durationMeasurement.durationInMs,
+            };
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "success",
+                    ...getResult(),
+                },
+            });
+        })();
+    });
+    if (!result.ok) {
+        const finishMetadata = {
+            eventType: "finished",
+            ...startMetadata,
+            finishTimestamp: new Date(),
+            durationInMs: durationMeasurement.durationInMs,
+        };
+        if (result.isAborted) {
+            eventSource.notify({
+                ...finishMetadata,
+                eventType: "finished",
+                result: {
+                    status: "abort",
+                },
+            });
+            throw new AbortError_js_1.AbortError();
+        }
+        eventSource.notify({
+            ...finishMetadata,
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
+        throw result.error;
+    }
+    return {
+        value: result.value,
+        metadata: startMetadata,
+    };
+}
+exports.executeStreamCall = executeStreamCall;

package/model-function/executeStreamCall.d.ts

@@ -0,0 +1,20 @@
+import { FunctionOptions } from "../core/FunctionOptions.js";
+import { Delta } from "./Delta.js";
+import { Model, ModelSettings } from "./Model.js";
+import { ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelCallMetadata } from "./ModelCallMetadata.js";
+export declare function executeStreamCall<DELTA_VALUE, VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, startStream, processDelta, processFinished, getResult, }: {
+    model: MODEL;
+    options?: FunctionOptions;
+    input: unknown;
+    functionType: ModelCallStartedEvent["functionType"];
+    startStream: (options?: FunctionOptions) => PromiseLike<AsyncIterable<Delta<DELTA_VALUE>>>;
+    processDelta: (delta: Delta<DELTA_VALUE> & {
+        type: "delta";
+    }) => VALUE | undefined;
+    processFinished?: () => VALUE | undefined;
+    getResult: () => Record<string, unknown>;
+}): Promise<{
+    value: AsyncIterable<VALUE>;
+    metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
+}>;