modelfusion 0.48.0 → 0.50.0

package/tool/useTool.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTool = void 0;
+const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
 const generateStructure_js_1 = require("../model-function/generate-structure/generateStructure.cjs");
 const executeTool_js_1 = require("./executeTool.cjs");
 /**
@@ -15,15 +16,22 @@ async function useTool(model, tool, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
         : prompt;
-    const { value } = await (0, generateStructure_js_1.generateStructure)(model, {
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    }, expandedPrompt, options).asFullResponse();
-    return {
-        tool: tool.name,
-        parameters: value,
-        result: await (0, executeTool_js_1.executeTool)(tool, value, options),
-    };
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => {
+            const { value } = await (0, generateStructure_js_1.generateStructure)(model, {
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            }, expandedPrompt, options).asFullResponse();
+            return {
+                tool: tool.name,
+                parameters: value,
+                result: await (0, executeTool_js_1.executeTool)(tool, value, options),
+            };
+        },
+    });
 }
 exports.useTool = useTool;

package/tool/useTool.js

@@ -1,3 +1,4 @@
+import { executeFunctionCall } from "../core/executeFunctionCall.js";
 import { generateStructure } from "../model-function/generate-structure/generateStructure.js";
 import { executeTool } from "./executeTool.js";
 /**
@@ -12,14 +13,21 @@ export async function useTool(model, tool, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
         : prompt;
-    const { value } = await generateStructure(model, {
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    }, expandedPrompt, options).asFullResponse();
-    return {
-        tool: tool.name,
-        parameters: value,
-        result: await executeTool(tool, value, options),
-    };
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => {
+            const { value } = await generateStructure(model, {
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            }, expandedPrompt, options).asFullResponse();
+            return {
+                tool: tool.name,
+                parameters: value,
+                result: await executeTool(tool, value, options),
+            };
+        },
+    });
 }

package/tool/useToolOrGenerateText.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useToolOrGenerateText = void 0;
+const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
 const generateStructureOrText_js_1 = require("../model-function/generate-structure/generateStructureOrText.cjs");
 const NoSuchToolError_js_1 = require("./NoSuchToolError.cjs");
 const executeTool_js_1 = require("./executeTool.cjs");
@@ -9,31 +10,38 @@ async function useToolOrGenerateText(model, tools, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const modelResponse = await (0, generateStructureOrText_js_1.generateStructureOrText)(model, tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    })), expandedPrompt, options);
-    const { structure, text } = modelResponse;
-    if (structure == null) {
-        return {
-            tool: null,
-            parameters: null,
-            result: null,
-            text,
-        };
-    }
-    const tool = tools.find((tool) => tool.name === structure);
-    if (tool == null) {
-        throw new NoSuchToolError_js_1.NoSuchToolError(structure.toString());
-    }
-    const toolParameters = modelResponse.value;
-    const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, options);
-    return {
-        tool: structure,
-        result,
-        parameters: toolParameters,
-        text: text, // string | null is the expected value here
-    };
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await (0, generateStructureOrText_js_1.generateStructureOrText)(model, tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            })), expandedPrompt, options);
+            const { structure, text } = modelResponse;
+            if (structure == null) {
+                return {
+                    tool: null,
+                    parameters: null,
+                    result: null,
+                    text,
+                };
+            }
+            const tool = tools.find((tool) => tool.name === structure);
+            if (tool == null) {
+                throw new NoSuchToolError_js_1.NoSuchToolError(structure.toString());
+            }
+            const toolParameters = modelResponse.value;
+            const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, options);
+            return {
+                tool: structure,
+                result,
+                parameters: toolParameters,
+                text: text, // string | null is the expected value here
+            };
+        },
+    });
 }
 exports.useToolOrGenerateText = useToolOrGenerateText;

package/tool/useToolOrGenerateText.js

@@ -1,3 +1,4 @@
+import { executeFunctionCall } from "../core/executeFunctionCall.js";
 import { generateStructureOrText } from "../model-function/generate-structure/generateStructureOrText.js";
 import { NoSuchToolError } from "./NoSuchToolError.js";
 import { executeTool } from "./executeTool.js";
@@ -6,30 +7,37 @@ export async function useToolOrGenerateText(model, tools, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const modelResponse = await generateStructureOrText(model, tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    })), expandedPrompt, options);
-    const { structure, text } = modelResponse;
-    if (structure == null) {
-        return {
-            tool: null,
-            parameters: null,
-            result: null,
-            text,
-        };
-    }
-    const tool = tools.find((tool) => tool.name === structure);
-    if (tool == null) {
-        throw new NoSuchToolError(structure.toString());
-    }
-    const toolParameters = modelResponse.value;
-    const result = await executeTool(tool, toolParameters, options);
-    return {
-        tool: structure,
-        result,
-        parameters: toolParameters,
-        text: text, // string | null is the expected value here
-    };
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await generateStructureOrText(model, tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            })), expandedPrompt, options);
+            const { structure, text } = modelResponse;
+            if (structure == null) {
+                return {
+                    tool: null,
+                    parameters: null,
+                    result: null,
+                    text,
+                };
+            }
+            const tool = tools.find((tool) => tool.name === structure);
+            if (tool == null) {
+                throw new NoSuchToolError(structure.toString());
+            }
+            const toolParameters = modelResponse.value;
+            const result = await executeTool(tool, toolParameters, options);
+            return {
+                tool: structure,
+                result,
+                parameters: toolParameters,
+                text: text, // string | null is the expected value here
+            };
+        },
+    });
 }

package/vector-index/UpsertIntoVectorIndexEvent.cjs

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

package/vector-index/UpsertIntoVectorIndexEvent.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface UpsertIntoVectorIndexStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "upsert-into-vector-index";
+    objects: unknown[];
+}
+export interface UpsertIntoVectorIndexFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "upsert-into-vector-index";
+    objects: unknown[];
+}

package/vector-index/UpsertIntoVectorIndexEvent.js

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

package/vector-index/VectorIndexRetriever.cjs

@@ -31,10 +31,7 @@ class VectorIndexRetriever {
         };
     }
     async retrieve(query, options) {
-        const embedding = await (0, embed_js_1.embed)(this.embeddingModel, query, {
-            functionId: options?.functionId,
-            run: options?.run,
-        });
+        const embedding = await (0, embed_js_1.embed)(this.embeddingModel, query, options);
         const queryResult = await this.vectorIndex.queryByVector({
             queryVector: embedding,
             maxResults: this.settings.maxResults ?? 1,

package/vector-index/VectorIndexRetriever.js

@@ -28,10 +28,7 @@ export class VectorIndexRetriever {
         };
     }
     async retrieve(query, options) {
-        const embedding = await embed(this.embeddingModel, query, {
-            functionId: options?.functionId,
-            run: options?.run,
-        });
+        const embedding = await embed(this.embeddingModel, query, options);
         const queryResult = await this.vectorIndex.queryByVector({
             queryVector: embedding,
             maxResults: this.settings.maxResults ?? 1,

package/vector-index/index.cjs

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./UpsertIntoVectorIndexEvent.cjs"), exports);
 __exportStar(require("./VectorIndex.cjs"), exports);
 __exportStar(require("./VectorIndexRetriever.cjs"), exports);
 __exportStar(require("./memory/MemoryVectorIndex.cjs"), exports);

package/vector-index/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./UpsertIntoVectorIndexEvent.js";
 export * from "./VectorIndex.js";
 export * from "./VectorIndexRetriever.js";
 export * from "./memory/MemoryVectorIndex.js";

package/vector-index/index.js

@@ -1,3 +1,4 @@
+export * from "./UpsertIntoVectorIndexEvent.js";
 export * from "./VectorIndex.js";
 export * from "./VectorIndexRetriever.js";
 export * from "./memory/MemoryVectorIndex.js";

package/vector-index/upsertIntoVectorIndex.cjs

@@ -2,14 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upsertIntoVectorIndex = void 0;
 const nanoid_1 = require("nanoid");
+const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
 const embed_js_1 = require("../model-function/embed/embed.cjs");
 async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId = nanoid_1.nanoid, objects, getValueToEmbed, getId, }, options) {
-    // many embedding models support bulk embedding, so we first embed all texts:
-    const embeddings = await (0, embed_js_1.embedMany)(embeddingModel, objects.map(getValueToEmbed), options);
-    await vectorIndex.upsertMany(objects.map((object, i) => ({
-        id: getId?.(object, i) ?? generateId(),
-        vector: embeddings[i],
-        data: object,
-    })));
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: objects,
+        functionType: "upsert-into-vector-index",
+        inputPropertyName: "objects",
+        execute: async (options) => {
+            // many embedding models support bulk embedding, so we first embed all texts:
+            const embeddings = await (0, embed_js_1.embedMany)(embeddingModel, objects.map(getValueToEmbed), options);
+            await vectorIndex.upsertMany(objects.map((object, i) => ({
+                id: getId?.(object, i) ?? generateId(),
+                vector: embeddings[i],
+                data: object,
+            })));
+        },
+    });
 }
 exports.upsertIntoVectorIndex = upsertIntoVectorIndex;

package/vector-index/upsertIntoVectorIndex.js

@@ -1,11 +1,20 @@
 import { nanoid as createId } from "nanoid";
+import { executeFunctionCall } from "../core/executeFunctionCall.js";
 import { embedMany } from "../model-function/embed/embed.js";
 export async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId = createId, objects, getValueToEmbed, getId, }, options) {
-    // many embedding models support bulk embedding, so we first embed all texts:
-    const embeddings = await embedMany(embeddingModel, objects.map(getValueToEmbed), options);
-    await vectorIndex.upsertMany(objects.map((object, i) => ({
-        id: getId?.(object, i) ?? generateId(),
-        vector: embeddings[i],
-        data: object,
-    })));
+    return executeFunctionCall({
+        options,
+        input: objects,
+        functionType: "upsert-into-vector-index",
+        inputPropertyName: "objects",
+        execute: async (options) => {
+            // many embedding models support bulk embedding, so we first embed all texts:
+            const embeddings = await embedMany(embeddingModel, objects.map(getValueToEmbed), options);
+            await vectorIndex.upsertMany(objects.map((object, i) => ({
+                id: getId?.(object, i) ?? generateId(),
+                vector: embeddings[i],
+                data: object,
+            })));
+        },
+    });
 }

package/model-function/describe-image/ImageDescriptionEvent.d.ts

@@ -1,18 +0,0 @@
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export interface ImageDescriptionStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "image-description";
-}
-export type ImageDescriptionFinishedEventResult = {
-    status: "success";
-    response: unknown;
-    value: string;
-} | {
-    status: "error";
-    error: unknown;
-} | {
-    status: "abort";
-};
-export interface ImageDescriptionFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "image-description";
-    result: ImageDescriptionFinishedEventResult;
-}

package/model-function/describe-image/ImageDescriptionModel.d.ts

@@ -1,10 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { Model, ModelSettings } from "../Model.js";
-export interface ImageDescriptionModelSettings extends ModelSettings {
-}
-export interface ImageDescriptionModel<DATA, SETTINGS extends ImageDescriptionModelSettings = ImageDescriptionModelSettings> extends Model<SETTINGS> {
-    doDescribeImage: (data: DATA, options?: FunctionOptions) => PromiseLike<{
-        response: unknown;
-        description: string;
-    }>;
-}

package/model-function/describe-image/describeImage.cjs

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.describeImage = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
-const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
-/**
- * Describe an image as text.
- *
- * Depending on the model, this can be used for image captioning, for describing the contents of an image, or for OCR.
- */
-function describeImage(model, data, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
-        functionType: "image-description",
-        input: data,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doDescribeImage(data, options);
-            return {
-                response: result.response,
-                extractedValue: result.description,
-            };
-        },
-    }));
-}
-exports.describeImage = describeImage;

package/model-function/describe-image/describeImage.d.ts

@@ -1,9 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
-import { ImageDescriptionModel, ImageDescriptionModelSettings } from "./ImageDescriptionModel.js";
-/**
- * Describe an image as text.
- *
- * Depending on the model, this can be used for image captioning, for describing the contents of an image, or for OCR.
- */
-export declare function describeImage<DATA>(model: ImageDescriptionModel<DATA, ImageDescriptionModelSettings>, data: DATA, options?: FunctionOptions): ModelFunctionPromise<string>;

package/model-function/describe-image/describeImage.js

@@ -1,22 +0,0 @@
-import { executeCall } from "../executeCall.js";
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
-/**
- * Describe an image as text.
- *
- * Depending on the model, this can be used for image captioning, for describing the contents of an image, or for OCR.
- */
-export function describeImage(model, data, options) {
-    return new ModelFunctionPromise(executeCall({
-        functionType: "image-description",
-        input: data,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doDescribeImage(data, options);
-            return {
-                response: result.response,
-                extractedValue: result.description,
-            };
-        },
-    }));
-}

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

@@ -1,7 +0,0 @@
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export interface TextStreamingStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "text-streaming";
-}
-export interface TextStreamingFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "text-streaming";
-}

package/model-function/synthesize-speech/SpeechSynthesisEvent.d.ts

@@ -1,21 +0,0 @@
-/// <reference types="node" />
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export interface SpeechSynthesisStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "speech-synthesis";
-    input: string;
-}
-export type SpeechSynthesisFinishedEventResult = {
-    status: "success";
-    response: unknown;
-    value: Buffer;
-} | {
-    status: "error";
-    error: unknown;
-} | {
-    status: "abort";
-};
-export interface SpeechSynthesisFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "speech-synthesis";
-    input: string;
-    result: SpeechSynthesisFinishedEventResult;
-}

package/model-function/synthesize-speech/SpeechSynthesisModel.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="node" />
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { Delta } from "../../model-function/Delta.js";
-import { Model, ModelSettings } from "../Model.js";
-export interface SpeechSynthesisModelSettings extends ModelSettings {
-}
-export interface SpeechSynthesisModel<SETTINGS extends SpeechSynthesisModelSettings = SpeechSynthesisModelSettings> extends Model<SETTINGS> {
-    /**
-     * Generates an mp3 audio buffer that contains the speech for the given text.
-     */
-    doSynthesizeSpeechStandard(text: string, options?: FunctionOptions): PromiseLike<Buffer>;
-}
-export interface DuplexSpeechSynthesisModel<SETTINGS extends SpeechSynthesisModelSettings = SpeechSynthesisModelSettings> extends SpeechSynthesisModel<SETTINGS> {
-    doSynthesizeSpeechStreamDuplex(textStream: AsyncIterable<string>, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<Buffer>>>;
-}

package/model-function/synthesize-speech/synthesizeSpeech.cjs

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.synthesizeSpeech = void 0;
-const AsyncIterableResultPromise_js_1 = require("../../model-function/AsyncIterableResultPromise.cjs");
-const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
-const executeCall_js_1 = require("../executeCall.cjs");
-function synthesizeSpeech(model, text, options) {
-    const mode = options?.mode ?? "standard";
-    switch (mode) {
-        case "standard": {
-            if (typeof text !== "string") {
-                throw new Error(`The "standard" mode only supports a string input, but received ${text}`);
-            }
-            return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
-                functionType: "speech-synthesis",
-                input: text,
-                model,
-                options,
-                generateResponse: async (options) => {
-                    const response = await model.doSynthesizeSpeechStandard(text, options);
-                    return {
-                        response,
-                        extractedValue: response,
-                    };
-                },
-            }));
-        }
-        case "stream-duplex": {
-            if (typeof text === "string") {
-                throw new Error(`The "stream-duplex" mode only supports an AsyncIterable<string> input, but received ${text}`);
-            }
-            if (!("doSynthesizeSpeechStreamDuplex" in model) ||
-                typeof model.doSynthesizeSpeechStreamDuplex !== "function") {
-                throw new Error(`The "stream-duplex" mode is not supported by this model.`);
-            }
-            return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise(doSynthesizeSpeechStreamDuplex(model, text, options));
-        }
-        default: {
-            const mode_ = mode;
-            throw new Error(`Unsupported mode: ${mode_}`);
-        }
-    }
-}
-exports.synthesizeSpeech = synthesizeSpeech;
-async function doSynthesizeSpeechStreamDuplex(model, text, options) {
-    const speechDeltas = await model.doSynthesizeSpeechStreamDuplex(text, options);
-    // Convert the speechDeltas (AsyncIterable<Delta<Buffer>>) to an AsyncIterable<Buffer>
-    const bufferStream = convertDeltasToBuffers(speechDeltas);
-    return {
-        output: bufferStream,
-        metadata: {
-            model: model.modelInformation,
-            callId: "test",
-            startTimestamp: new Date(),
-        },
-    };
-}
-async function* convertDeltasToBuffers(deltas) {
-    for await (const delta of deltas) {
-        switch (delta.type) {
-            case "error":
-                throw delta.error;
-            case "delta":
-                yield delta.valueDelta;
-        }
-    }
-}

package/model-function/synthesize-speech/synthesizeSpeech.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="node" />
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { AsyncIterableResultPromise } from "../../model-function/AsyncIterableResultPromise.js";
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
-import { DuplexSpeechSynthesisModel, SpeechSynthesisModel, SpeechSynthesisModelSettings } from "./SpeechSynthesisModel.js";
-/**
- * Synthesizes speech from text.
- */
-export declare function synthesizeSpeech(model: SpeechSynthesisModel<SpeechSynthesisModelSettings>, text: string, options?: FunctionOptions & {
-    mode?: "standard";
-}): ModelFunctionPromise<Buffer>;
-export declare function synthesizeSpeech(model: DuplexSpeechSynthesisModel<SpeechSynthesisModelSettings>, text: AsyncIterable<string>, options: FunctionOptions & {
-    mode: "stream-duplex";
-}): AsyncIterableResultPromise<Buffer>;

package/model-function/synthesize-speech/synthesizeSpeech.js

@@ -1,63 +0,0 @@
-import { AsyncIterableResultPromise } from "../../model-function/AsyncIterableResultPromise.js";
-import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
-import { executeCall } from "../executeCall.js";
-export function synthesizeSpeech(model, text, options) {
-    const mode = options?.mode ?? "standard";
-    switch (mode) {
-        case "standard": {
-            if (typeof text !== "string") {
-                throw new Error(`The "standard" mode only supports a string input, but received ${text}`);
-            }
-            return new ModelFunctionPromise(executeCall({
-                functionType: "speech-synthesis",
-                input: text,
-                model,
-                options,
-                generateResponse: async (options) => {
-                    const response = await model.doSynthesizeSpeechStandard(text, options);
-                    return {
-                        response,
-                        extractedValue: response,
-                    };
-                },
-            }));
-        }
-        case "stream-duplex": {
-            if (typeof text === "string") {
-                throw new Error(`The "stream-duplex" mode only supports an AsyncIterable<string> input, but received ${text}`);
-            }
-            if (!("doSynthesizeSpeechStreamDuplex" in model) ||
-                typeof model.doSynthesizeSpeechStreamDuplex !== "function") {
-                throw new Error(`The "stream-duplex" mode is not supported by this model.`);
-            }
-            return new AsyncIterableResultPromise(doSynthesizeSpeechStreamDuplex(model, text, options));
-        }
-        default: {
-            const mode_ = mode;
-            throw new Error(`Unsupported mode: ${mode_}`);
-        }
-    }
-}
-async function doSynthesizeSpeechStreamDuplex(model, text, options) {
-    const speechDeltas = await model.doSynthesizeSpeechStreamDuplex(text, options);
-    // Convert the speechDeltas (AsyncIterable<Delta<Buffer>>) to an AsyncIterable<Buffer>
-    const bufferStream = convertDeltasToBuffers(speechDeltas);
-    return {
-        output: bufferStream,
-        metadata: {
-            model: model.modelInformation,
-            callId: "test",
-            startTimestamp: new Date(),
-        },
-    };
-}
-async function* convertDeltasToBuffers(deltas) {
-    for await (const delta of deltas) {
-        switch (delta.type) {
-            case "error":
-                throw delta.error;
-            case "delta":
-                yield delta.valueDelta;
-        }
-    }
-}