modelfusion 0.57.2 → 0.58.0

package/README.md

@@ -513,7 +513,7 @@ const image = await generateImage(
 
 ### Metadata and original responses
 
-ModelFusion model functions return rich results that include the original response and metadata when you call `.asFullResponse()` before resolving the promise.
+ModelFusion model functions return rich results that include the original response and metadata when you set the `returnType` option to `full`.
 
 ```ts
 // access the full response (needs to be typed) and the metadata:
@@ -523,8 +523,9 @@ const { value, response, metadata } = await generateText(
     maxCompletionTokens: 1000,
     n: 2, // generate 2 completions
   }),
-  "Write a short story about a robot learning to love:\n\n"
-).asFullResponse();
+  "Write a short story about a robot learning to love:\n\n",
+  { returnType: "full" }
+);
 
 console.log(metadata);
 

package/core/api/retryWithExponentialBackoff.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retryWithExponentialBackoff = void 0;
+const delay_js_1 = require("../../util/delay.cjs");
 const ApiCallError_js_1 = require("./ApiCallError.cjs");
 const RetryError_js_1 = require("./RetryError.cjs");
 /**
@@ -9,11 +10,11 @@ const RetryError_js_1 = require("./RetryError.cjs");
  */
 const retryWithExponentialBackoff = ({ maxTries = 3, initialDelayInMs = 2000, backoffFactor = 2, } = {}) => async (f) => _retryWithExponentialBackoff(f, {
     maxTries,
-    delay: initialDelayInMs,
+    delayInMs: initialDelayInMs,
     backoffFactor,
 });
 exports.retryWithExponentialBackoff = retryWithExponentialBackoff;
-async function _retryWithExponentialBackoff(f, { maxTries, delay, backoffFactor, }, errors = []) {
+async function _retryWithExponentialBackoff(f, { maxTries, delayInMs, backoffFactor, }, errors = []) {
     try {
         return await f();
     }
@@ -34,8 +35,8 @@ async function _retryWithExponentialBackoff(f, { maxTries, delay, backoffFactor,
             if (error instanceof ApiCallError_js_1.ApiCallError &&
                 error.isRetryable &&
                 tryNumber < maxTries) {
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                return _retryWithExponentialBackoff(f, { maxTries, delay: backoffFactor * delay, backoffFactor }, newErrors);
+                await (0, delay_js_1.delay)(delayInMs);
+                return _retryWithExponentialBackoff(f, { maxTries, delayInMs: backoffFactor * delayInMs, backoffFactor }, newErrors);
             }
         }
         const errorMessage = error instanceof Error ? error.message : String(error);

package/core/api/retryWithExponentialBackoff.js

@@ -1,3 +1,4 @@
+import { delay } from "../../util/delay.js";
 import { ApiCallError } from "./ApiCallError.js";
 import { RetryError } from "./RetryError.js";
 /**
@@ -6,10 +7,10 @@ import { RetryError } from "./RetryError.js";
  */
 export const retryWithExponentialBackoff = ({ maxTries = 3, initialDelayInMs = 2000, backoffFactor = 2, } = {}) => async (f) => _retryWithExponentialBackoff(f, {
     maxTries,
-    delay: initialDelayInMs,
+    delayInMs: initialDelayInMs,
     backoffFactor,
 });
-async function _retryWithExponentialBackoff(f, { maxTries, delay, backoffFactor, }, errors = []) {
+async function _retryWithExponentialBackoff(f, { maxTries, delayInMs, backoffFactor, }, errors = []) {
     try {
         return await f();
     }
@@ -30,8 +31,8 @@ async function _retryWithExponentialBackoff(f, { maxTries, delay, backoffFactor,
             if (error instanceof ApiCallError &&
                 error.isRetryable &&
                 tryNumber < maxTries) {
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                return _retryWithExponentialBackoff(f, { maxTries, delay: backoffFactor * delay, backoffFactor }, newErrors);
+                await delay(delayInMs);
+                return _retryWithExponentialBackoff(f, { maxTries, delayInMs: backoffFactor * delayInMs, backoffFactor }, newErrors);
             }
         }
         const errorMessage = error instanceof Error ? error.message : String(error);

package/model-function/embed/embed.cjs

@@ -2,29 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.embed = exports.embedMany = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
-/**
- * Generate embeddings for multiple values.
- *
- * @see https://modelfusion.dev/guide/function/embed
- *
- * @example
- * const embeddings = await embedMany(
- *   new OpenAITextEmbeddingModel(...),
- *   [
- *     "At first, Nox didn't know what to do with the pup.",
- *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
- *   ]
- * );
- *
- * @param {EmbeddingModel<VALUE, EmbeddingModelSettings>} model - The model to use for generating embeddings.
- * @param {VALUE[]} values - The values to generate embeddings for.
- * @param {FunctionOptions} [options] - Optional settings for the function.
- *
- * @returns {ModelFunctionPromise<Vector[]>} - A promise that resolves to an array of vectors representing the embeddings.
- */
-function embedMany(model, values, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+async function embedMany(model, values, options) {
+    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "embed",
         input: values,
         model,
@@ -63,28 +42,12 @@ function embedMany(model, values, options) {
                 extractedValue: embeddings,
             };
         },
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }
 exports.embedMany = embedMany;
-/**
- * Generate an embedding for a single value.
- *
- * @see https://modelfusion.dev/guide/function/embed
- *
- * @example
- * const embedding = await embed(
- *   new OpenAITextEmbeddingModel(...),
- *   "At first, Nox didn't know what to do with the pup."
- * );
- *
- * @param {EmbeddingModel<VALUE, EmbeddingModelSettings>} model - The model to use for generating the embedding.
- * @param {VALUE} value - The value to generate an embedding for.
- * @param {FunctionOptions} [options] - Optional settings for the function.
- *
- * @returns {ModelFunctionPromise<Vector>} - A promise that resolves to a vector representing the embedding.
- */
-function embed(model, value, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+async function embed(model, value, options) {
+    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "embed",
         input: value,
         model,
@@ -96,6 +59,7 @@ function embed(model, value, options) {
                 extractedValue: result.embeddings[0],
             };
         },
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }
 exports.embed = embed;

package/model-function/embed/embed.d.ts

@@ -1,6 +1,6 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Vector } from "../../core/Vector.js";
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "./EmbeddingModel.js";
 /**
  * Generate embeddings for multiple values.
@@ -20,9 +20,18 @@ import { EmbeddingModel, EmbeddingModelSettings } from "./EmbeddingModel.js";
  * @param {VALUE[]} values - The values to generate embeddings for.
  * @param {FunctionOptions} [options] - Optional settings for the function.
  *
- * @returns {ModelFunctionPromise<Vector[]>} - A promise that resolves to an array of vectors representing the embeddings.
+ * @returns {Promise<Vector[]>} - A promise that resolves to an array of vectors representing the embeddings.
  */
-export declare function embedMany<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, values: VALUE[], options?: FunctionOptions): ModelFunctionPromise<Vector[]>;
+export declare function embedMany<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, values: VALUE[], options?: FunctionOptions & {
+    returnType?: "vectors";
+}): Promise<Vector[]>;
+export declare function embedMany<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, values: VALUE[], options: FunctionOptions & {
+    returnType: "full";
+}): Promise<{
+    value: Vector[];
+    response: unknown;
+    metadata: ModelCallMetadata;
+}>;
 /**
  * Generate an embedding for a single value.
  *
@@ -38,6 +47,15 @@ export declare function embedMany<VALUE>(model: EmbeddingModel<VALUE, EmbeddingM
  * @param {VALUE} value - The value to generate an embedding for.
  * @param {FunctionOptions} [options] - Optional settings for the function.
  *
- * @returns {ModelFunctionPromise<Vector>} - A promise that resolves to a vector representing the embedding.
+ * @returns {Promise<Vector>} - A promise that resolves to a vector representing the embedding.
  */
-export declare function embed<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, value: VALUE, options?: FunctionOptions): ModelFunctionPromise<Vector>;
+export declare function embed<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, value: VALUE, options?: FunctionOptions & {
+    returnType?: "vector";
+}): Promise<Vector>;
+export declare function embed<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, value: VALUE, options: FunctionOptions & {
+    returnType: "full";
+}): Promise<{
+    value: Vector;
+    response: unknown;
+    metadata: ModelCallMetadata;
+}>;

package/model-function/embed/embed.js

@@ -1,27 +1,6 @@
 import { executeStandardCall } from "../executeStandardCall.js";
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
-/**
- * Generate embeddings for multiple values.
- *
- * @see https://modelfusion.dev/guide/function/embed
- *
- * @example
- * const embeddings = await embedMany(
- *   new OpenAITextEmbeddingModel(...),
- *   [
- *     "At first, Nox didn't know what to do with the pup.",
- *     "He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest.",
- *   ]
- * );
- *
- * @param {EmbeddingModel<VALUE, EmbeddingModelSettings>} model - The model to use for generating embeddings.
- * @param {VALUE[]} values - The values to generate embeddings for.
- * @param {FunctionOptions} [options] - Optional settings for the function.
- *
- * @returns {ModelFunctionPromise<Vector[]>} - A promise that resolves to an array of vectors representing the embeddings.
- */
-export function embedMany(model, values, options) {
-    return new ModelFunctionPromise(executeStandardCall({
+export async function embedMany(model, values, options) {
+    const fullResponse = await executeStandardCall({
         functionType: "embed",
         input: values,
         model,
@@ -60,27 +39,11 @@ export function embedMany(model, values, options) {
                 extractedValue: embeddings,
             };
         },
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }
-/**
- * Generate an embedding for a single value.
- *
- * @see https://modelfusion.dev/guide/function/embed
- *
- * @example
- * const embedding = await embed(
- *   new OpenAITextEmbeddingModel(...),
- *   "At first, Nox didn't know what to do with the pup."
- * );
- *
- * @param {EmbeddingModel<VALUE, EmbeddingModelSettings>} model - The model to use for generating the embedding.
- * @param {VALUE} value - The value to generate an embedding for.
- * @param {FunctionOptions} [options] - Optional settings for the function.
- *
- * @returns {ModelFunctionPromise<Vector>} - A promise that resolves to a vector representing the embedding.
- */
-export function embed(model, value, options) {
-    return new ModelFunctionPromise(executeStandardCall({
+export async function embed(model, value, options) {
+    const fullResponse = await executeStandardCall({
         functionType: "embed",
         input: value,
         model,
@@ -92,5 +55,6 @@ export function embed(model, value, options) {
                 extractedValue: result.embeddings[0],
             };
         },
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }

package/model-function/generate-image/generateImage.cjs

@@ -2,33 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateImage = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-const ImageGenerationPromise_js_1 = require("./ImageGenerationPromise.cjs");
-/**
- * Generates an image using a prompt.
- *
- * The prompt depends on the model. For example, OpenAI image models expect a string prompt,
- * and Stability AI models expect an array of text prompts with optional weights.
- *
- * @see https://modelfusion.dev/guide/function/generate-image
- *
- * @example
- * const image = await generateImage(
- *   new StabilityImageGenerationModel(...),
- *   [
- *     { text: "the wicked witch of the west" },
- *     { text: "style of early 19th century painting", weight: 0.5 },
- *   ]
- * );
- *
- * @param {ImageGenerationModel<PROMPT, ImageGenerationModelSettings>} model - The image generation model to be used.
- * @param {PROMPT} prompt - The prompt to be used for image generation.
- * @param {FunctionOptions} [options] - Optional settings for the function.
- *
- * @returns {ImageGenerationPromise} - Returns a promise that resolves to the generated image.
- * The image is a Buffer containing the image data in PNG format.
- */
-function generateImage(model, prompt, options) {
-    return new ImageGenerationPromise_js_1.ImageGenerationPromise((0, executeStandardCall_js_1.executeStandardCall)({
+async function generateImage(model, prompt, options) {
+    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-image",
         input: prompt,
         model,
@@ -40,6 +15,15 @@ function generateImage(model, prompt, options) {
                 extractedValue: result.base64Image,
             };
         },
-    }));
+    });
+    switch (options?.returnType) {
+        case "full":
+            return fullResponse;
+        case "base64":
+            return fullResponse.value;
+        case "buffer":
+        default:
+            return Buffer.from(fullResponse.value, "base64");
+    }
 }
 exports.generateImage = generateImage;

package/model-function/generate-image/generateImage.d.ts

@@ -1,6 +1,7 @@
+/// <reference types="node" />
 import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
-import { ImageGenerationPromise } from "./ImageGenerationPromise.js";
 /**
  * Generates an image using a prompt.
  *
@@ -22,7 +23,19 @@ import { ImageGenerationPromise } from "./ImageGenerationPromise.js";
  * @param {PROMPT} prompt - The prompt to be used for image generation.
  * @param {FunctionOptions} [options] - Optional settings for the function.
  *
- * @returns {ImageGenerationPromise} - Returns a promise that resolves to the generated image.
+ * @returns {Promise} - Returns a promise that resolves to the generated image.
  * The image is a Buffer containing the image data in PNG format.
  */
-export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options?: FunctionOptions): ImageGenerationPromise;
+export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options?: FunctionOptions & {
+    returnType?: "buffer";
+}): Promise<Buffer>;
+export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options: FunctionOptions & {
+    returnType: "base64";
+}): Promise<string>;
+export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options: FunctionOptions & {
+    returnType: "full";
+}): Promise<{
+    value: string;
+    response: unknown;
+    metadata: ModelCallMetadata;
+}>;

package/model-function/generate-image/generateImage.js

@@ -1,31 +1,6 @@
 import { executeStandardCall } from "../executeStandardCall.js";
-import { ImageGenerationPromise } from "./ImageGenerationPromise.js";
-/**
- * Generates an image using a prompt.
- *
- * The prompt depends on the model. For example, OpenAI image models expect a string prompt,
- * and Stability AI models expect an array of text prompts with optional weights.
- *
- * @see https://modelfusion.dev/guide/function/generate-image
- *
- * @example
- * const image = await generateImage(
- *   new StabilityImageGenerationModel(...),
- *   [
- *     { text: "the wicked witch of the west" },
- *     { text: "style of early 19th century painting", weight: 0.5 },
- *   ]
- * );
- *
- * @param {ImageGenerationModel<PROMPT, ImageGenerationModelSettings>} model - The image generation model to be used.
- * @param {PROMPT} prompt - The prompt to be used for image generation.
- * @param {FunctionOptions} [options] - Optional settings for the function.
- *
- * @returns {ImageGenerationPromise} - Returns a promise that resolves to the generated image.
- * The image is a Buffer containing the image data in PNG format.
- */
-export function generateImage(model, prompt, options) {
-    return new ImageGenerationPromise(executeStandardCall({
+export async function generateImage(model, prompt, options) {
+    const fullResponse = await executeStandardCall({
         functionType: "generate-image",
         input: prompt,
         model,
@@ -37,5 +12,14 @@ export function generateImage(model, prompt, options) {
                 extractedValue: result.base64Image,
             };
         },
-    }));
+    });
+    switch (options?.returnType) {
+        case "full":
+            return fullResponse;
+        case "base64":
+            return fullResponse.value;
+        case "buffer":
+        default:
+            return Buffer.from(fullResponse.value, "base64");
+    }
 }

package/model-function/generate-speech/generateSpeech.cjs

@@ -1,28 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSpeech = void 0;
-const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-/**
- * Synthesizes speech from text. Also called text-to-speech (TTS).
- *
- * @see https://modelfusion.dev/guide/function/generate-speech
- *
- * @example
- * const speech = await generateSpeech(
- *   new LmntSpeechModel(...),
- *   "Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
- *    "as The Rolling Stones unveil 'Hackney Diamonds.'
- * );
- *
- * @param {SpeechGenerationModel<SpeechGenerationModelSettings>} model - The speech generation model.
- * @param {string} text - The text to be converted to speech.
- * @param {FunctionOptions} [options] - Optional function options.
- *
- * @returns {ModelFunctionPromise<Buffer>} - A promise that resolves to a buffer containing the synthesized speech.
- */
-function generateSpeech(model, text, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+async function generateSpeech(model, text, options) {
+    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-speech",
         input: text,
         model,
@@ -34,6 +15,7 @@ function generateSpeech(model, text, options) {
                 extractedValue: response,
             };
         },
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }
 exports.generateSpeech = generateSpeech;

package/model-function/generate-speech/generateSpeech.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
 import { SpeechGenerationModel, SpeechGenerationModelSettings } from "./SpeechGenerationModel.js";
 /**
  * Synthesizes speech from text. Also called text-to-speech (TTS).
@@ -18,6 +18,15 @@ import { SpeechGenerationModel, SpeechGenerationModelSettings } from "./SpeechGe
  * @param {string} text - The text to be converted to speech.
  * @param {FunctionOptions} [options] - Optional function options.
  *
- * @returns {ModelFunctionPromise<Buffer>} - A promise that resolves to a buffer containing the synthesized speech.
+ * @returns {Promise<Buffer>} - A promise that resolves to a buffer containing the synthesized speech.
  */
-export declare function generateSpeech(model: SpeechGenerationModel<SpeechGenerationModelSettings>, text: string, options?: FunctionOptions): ModelFunctionPromise<Buffer>;
+export declare function generateSpeech(model: SpeechGenerationModel<SpeechGenerationModelSettings>, text: string, options?: FunctionOptions & {
+    returnType?: "buffer";
+}): Promise<Buffer>;
+export declare function generateSpeech(model: SpeechGenerationModel<SpeechGenerationModelSettings>, text: string, options: FunctionOptions & {
+    returnType: "full";
+}): Promise<{
+    value: Buffer;
+    response: unknown;
+    metadata: ModelCallMetadata;
+}>;

package/model-function/generate-speech/generateSpeech.js

@@ -1,25 +1,6 @@
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 import { executeStandardCall } from "../executeStandardCall.js";
-/**
- * Synthesizes speech from text. Also called text-to-speech (TTS).
- *
- * @see https://modelfusion.dev/guide/function/generate-speech
- *
- * @example
- * const speech = await generateSpeech(
- *   new LmntSpeechModel(...),
- *   "Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
- *    "as The Rolling Stones unveil 'Hackney Diamonds.'
- * );
- *
- * @param {SpeechGenerationModel<SpeechGenerationModelSettings>} model - The speech generation model.
- * @param {string} text - The text to be converted to speech.
- * @param {FunctionOptions} [options] - Optional function options.
- *
- * @returns {ModelFunctionPromise<Buffer>} - A promise that resolves to a buffer containing the synthesized speech.
- */
-export function generateSpeech(model, text, options) {
-    return new ModelFunctionPromise(executeStandardCall({
+export async function generateSpeech(model, text, options) {
+    const fullResponse = await executeStandardCall({
         functionType: "generate-speech",
         input: text,
         model,
@@ -31,5 +12,6 @@ export function generateSpeech(model, text, options) {
                 extractedValue: response,
             };
         },
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }

package/model-function/generate-speech/streamSpeech.cjs

@@ -2,33 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamSpeech = void 0;
 const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
-const AsyncIterableResultPromise_js_1 = require("../AsyncIterableResultPromise.cjs");
 const executeStreamCall_js_1 = require("../executeStreamCall.cjs");
-/**
- * Stream synthesized speech from text. Also called text-to-speech (TTS).
- * Duplex streaming where both the input and output are streamed is supported.
- *
- * @see https://modelfusion.dev/guide/function/generate-speech
- *
- * @example
- * const textStream = await streamText(...);
- *
- * const speechStream = await streamSpeech(
- *   new ElevenLabsSpeechModel(...),
- *   textStream
- * );
- *
- * for await (const speechPart of speechStream) {
- *   // ...
- * }
- *
- * @param {StreamingSpeechGenerationModel<SpeechGenerationModelSettings>} model - The speech generation model.
- * @param {AsyncIterable<string> | string} text - The text to be converted to speech. Can be a string or an async iterable of strings.
- * @param {FunctionOptions} [options] - Optional function options.
- *
- * @returns {AsyncIterableResultPromise<Buffer>} An async iterable promise that contains the synthesized speech chunks.
- */
-function streamSpeech(model, text, options) {
+async function streamSpeech(model, text, options) {
     let textStream;
     // simulate a stream with a single value for a string input:
     if (typeof text === "string") {
@@ -40,16 +15,15 @@ function streamSpeech(model, text, options) {
     else {
         textStream = text;
     }
-    return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise((0, executeStreamCall_js_1.executeStreamCall)({
+    const fullResponse = await (0, executeStreamCall_js_1.executeStreamCall)({
         functionType: "stream-speech",
         input: text,
         model,
         options,
         startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
-        processDelta: (delta) => {
-            return delta.valueDelta;
-        },
+        processDelta: (delta) => delta.valueDelta,
         getResult: () => ({}),
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }
 exports.streamSpeech = streamSpeech;

package/model-function/generate-speech/streamSpeech.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
-import { StreamingSpeechGenerationModel, SpeechGenerationModelSettings } from "./SpeechGenerationModel.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
+import { SpeechGenerationModelSettings, StreamingSpeechGenerationModel } from "./SpeechGenerationModel.js";
 /**
  * Stream synthesized speech from text. Also called text-to-speech (TTS).
  * Duplex streaming where both the input and output are streamed is supported.
@@ -26,4 +26,12 @@ import { StreamingSpeechGenerationModel, SpeechGenerationModelSettings } from ".
  *
  * @returns {AsyncIterableResultPromise<Buffer>} An async iterable promise that contains the synthesized speech chunks.
  */
-export declare function streamSpeech(model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>, text: AsyncIterable<string> | string, options?: FunctionOptions): AsyncIterableResultPromise<Buffer>;
+export declare function streamSpeech(model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>, text: AsyncIterable<string> | string, options?: FunctionOptions & {
+    returnType?: "buffer-stream";
+}): Promise<AsyncIterable<Buffer>>;
+export declare function streamSpeech(model: StreamingSpeechGenerationModel<SpeechGenerationModelSettings>, text: AsyncIterable<string> | string, options: FunctionOptions & {
+    returnType: "full";
+}): Promise<{
+    value: AsyncIterable<Buffer>;
+    metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
+}>;

package/model-function/generate-speech/streamSpeech.js

@@ -1,31 +1,6 @@
 import { AsyncQueue } from "../../util/AsyncQueue.js";
-import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
 import { executeStreamCall } from "../executeStreamCall.js";
-/**
- * Stream synthesized speech from text. Also called text-to-speech (TTS).
- * Duplex streaming where both the input and output are streamed is supported.
- *
- * @see https://modelfusion.dev/guide/function/generate-speech
- *
- * @example
- * const textStream = await streamText(...);
- *
- * const speechStream = await streamSpeech(
- *   new ElevenLabsSpeechModel(...),
- *   textStream
- * );
- *
- * for await (const speechPart of speechStream) {
- *   // ...
- * }
- *
- * @param {StreamingSpeechGenerationModel<SpeechGenerationModelSettings>} model - The speech generation model.
- * @param {AsyncIterable<string> | string} text - The text to be converted to speech. Can be a string or an async iterable of strings.
- * @param {FunctionOptions} [options] - Optional function options.
- *
- * @returns {AsyncIterableResultPromise<Buffer>} An async iterable promise that contains the synthesized speech chunks.
- */
-export function streamSpeech(model, text, options) {
+export async function streamSpeech(model, text, options) {
     let textStream;
     // simulate a stream with a single value for a string input:
     if (typeof text === "string") {
@@ -37,15 +12,14 @@ export function streamSpeech(model, text, options) {
     else {
         textStream = text;
     }
-    return new AsyncIterableResultPromise(executeStreamCall({
+    const fullResponse = await executeStreamCall({
         functionType: "stream-speech",
         input: text,
         model,
         options,
         startStream: async (options) => model.doGenerateSpeechStreamDuplex(textStream, options),
-        processDelta: (delta) => {
-            return delta.valueDelta;
-        },
+        processDelta: (delta) => delta.valueDelta,
         getResult: () => ({}),
-    }));
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
 }

package/model-function/generate-structure/StructureFromTextGenerationModel.cjs

@@ -30,7 +30,10 @@ class StructureFromTextGenerationModel {
         return this.model.settingsForEvent;
     }
     async doGenerateStructure(structure, prompt, options) {
-        const { response, value } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, structure), options).asFullResponse();
+        const { response, value } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, structure), {
+            ...options,
+            returnType: "full",
+        });
         try {
             return {
                 response,