modelfusion 0.121.2 → 0.123.0

package/model-function/classify/EmbeddingSimilarityClassifier.cjs

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingSimilarityClassifier = void 0;
+const cosineSimilarity_js_1 = require("../../util/cosineSimilarity.cjs");
+const embed_js_1 = require("../embed/embed.cjs");
+/**
+ * Classifies values based on their distance to the values from a set of clusters.
+ * When the distance is below a certain threshold, the value is classified as belonging to the cluster,
+ * and the cluster name is returned. Otherwise, the value is classified as null.
+ */
+class EmbeddingSimilarityClassifier {
+    constructor(settings) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelInformation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                provider: "modelfusion",
+                modelName: "EmbeddingSimilarityClassifier",
+            }
+        });
+        Object.defineProperty(this, "embeddings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    async getEmbeddings(options) {
+        if (this.embeddings != null) {
+            return this.embeddings;
+        }
+        const embeddings = [];
+        for (const cluster of this.settings.clusters) {
+            const clusterEmbeddings = await (0, embed_js_1.embedMany)({
+                model: this.settings.embeddingModel,
+                values: cluster.values,
+                ...options,
+            });
+            for (let i = 0; i < clusterEmbeddings.length; i++) {
+                embeddings.push({
+                    embedding: clusterEmbeddings[i],
+                    clusterValue: cluster.values[i],
+                    clusterName: cluster.name,
+                });
+            }
+        }
+        this.embeddings = embeddings; // lazy caching
+        return embeddings;
+    }
+    async doClassify(value, options) {
+        const valueEmbedding = await (0, embed_js_1.embed)({
+            model: this.settings.embeddingModel,
+            value,
+            ...options,
+        });
+        const clusterEmbeddings = await this.getEmbeddings(options);
+        const allMatches = [];
+        for (const embedding of clusterEmbeddings) {
+            const similarity = (0, cosineSimilarity_js_1.cosineSimilarity)(valueEmbedding, embedding.embedding);
+            if (similarity >= this.settings.similarityThreshold) {
+                allMatches.push({
+                    similarity,
+                    clusterValue: embedding.clusterValue,
+                    clusterName: embedding.clusterName,
+                });
+            }
+        }
+        // sort (highest similarity first)
+        allMatches.sort((a, b) => b.similarity - a.similarity);
+        return {
+            class: allMatches.length > 0
+                ? allMatches[0].clusterName
+                : null,
+            rawResponse: undefined,
+        };
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "clusters",
+            "embeddingModel",
+            "similarityThreshold",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    withSettings(additionalSettings) {
+        return new EmbeddingSimilarityClassifier(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.EmbeddingSimilarityClassifier = EmbeddingSimilarityClassifier;

package/model-function/classify/EmbeddingSimilarityClassifier.d.ts

@@ -0,0 +1,40 @@
+import { FunctionCallOptions } from "../../core/FunctionOptions.js";
+import { Vector } from "../../core/Vector.js";
+import { EmbeddingModel } from "../embed/EmbeddingModel.js";
+import { Classifier, ClassifierSettings } from "./Classifier.js";
+export interface ValueCluster<VALUE, NAME extends string> {
+    name: NAME;
+    values: VALUE[];
+}
+export interface EmbeddingSimilarityClassifierSettings<VALUE, CLUSTERS extends Array<ValueCluster<VALUE, string>>> extends ClassifierSettings {
+    clusters: CLUSTERS;
+    embeddingModel: EmbeddingModel<VALUE>;
+    similarityThreshold: number;
+}
+/**
+ * Classifies values based on their distance to the values from a set of clusters.
+ * When the distance is below a certain threshold, the value is classified as belonging to the cluster,
+ * and the cluster name is returned. Otherwise, the value is classified as null.
+ */
+export declare class EmbeddingSimilarityClassifier<VALUE, CLUSTERS extends Array<ValueCluster<VALUE, string>>> implements Classifier<VALUE, ClusterNames<CLUSTERS> | null, EmbeddingSimilarityClassifierSettings<VALUE, CLUSTERS>> {
+    readonly settings: EmbeddingSimilarityClassifierSettings<VALUE, CLUSTERS>;
+    readonly modelInformation: {
+        provider: string;
+        modelName: string;
+    };
+    private embeddings;
+    constructor(settings: EmbeddingSimilarityClassifierSettings<VALUE, CLUSTERS>);
+    getEmbeddings(options: FunctionCallOptions): Promise<{
+        embedding: Vector;
+        clusterValue: VALUE;
+        clusterName: string;
+    }[]>;
+    doClassify(value: VALUE, options: FunctionCallOptions): Promise<{
+        class: ClusterNames<CLUSTERS> | null;
+        rawResponse: undefined;
+    }>;
+    get settingsForEvent(): Partial<EmbeddingSimilarityClassifierSettings<VALUE, CLUSTERS>>;
+    withSettings(additionalSettings: Partial<EmbeddingSimilarityClassifierSettings<VALUE, CLUSTERS>>): this;
+}
+type ClusterNames<CLUSTERS> = CLUSTERS extends Array<ValueCluster<unknown, infer NAME>> ? NAME : never;
+export {};

package/model-function/classify/EmbeddingSimilarityClassifier.js

@@ -0,0 +1,93 @@
+import { cosineSimilarity } from "../../util/cosineSimilarity.js";
+import { embed, embedMany } from "../embed/embed.js";
+/**
+ * Classifies values based on their distance to the values from a set of clusters.
+ * When the distance is below a certain threshold, the value is classified as belonging to the cluster,
+ * and the cluster name is returned. Otherwise, the value is classified as null.
+ */
+export class EmbeddingSimilarityClassifier {
+    constructor(settings) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelInformation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                provider: "modelfusion",
+                modelName: "EmbeddingSimilarityClassifier",
+            }
+        });
+        Object.defineProperty(this, "embeddings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    async getEmbeddings(options) {
+        if (this.embeddings != null) {
+            return this.embeddings;
+        }
+        const embeddings = [];
+        for (const cluster of this.settings.clusters) {
+            const clusterEmbeddings = await embedMany({
+                model: this.settings.embeddingModel,
+                values: cluster.values,
+                ...options,
+            });
+            for (let i = 0; i < clusterEmbeddings.length; i++) {
+                embeddings.push({
+                    embedding: clusterEmbeddings[i],
+                    clusterValue: cluster.values[i],
+                    clusterName: cluster.name,
+                });
+            }
+        }
+        this.embeddings = embeddings; // lazy caching
+        return embeddings;
+    }
+    async doClassify(value, options) {
+        const valueEmbedding = await embed({
+            model: this.settings.embeddingModel,
+            value,
+            ...options,
+        });
+        const clusterEmbeddings = await this.getEmbeddings(options);
+        const allMatches = [];
+        for (const embedding of clusterEmbeddings) {
+            const similarity = cosineSimilarity(valueEmbedding, embedding.embedding);
+            if (similarity >= this.settings.similarityThreshold) {
+                allMatches.push({
+                    similarity,
+                    clusterValue: embedding.clusterValue,
+                    clusterName: embedding.clusterName,
+                });
+            }
+        }
+        // sort (highest similarity first)
+        allMatches.sort((a, b) => b.similarity - a.similarity);
+        return {
+            class: allMatches.length > 0
+                ? allMatches[0].clusterName
+                : null,
+            rawResponse: undefined,
+        };
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "clusters",
+            "embeddingModel",
+            "similarityThreshold",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    withSettings(additionalSettings) {
+        return new EmbeddingSimilarityClassifier(Object.assign({}, this.settings, additionalSettings));
+    }
+}

package/model-function/classify/classify.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classify = void 0;
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
+async function classify({ model, value, fullResponse, ...options }) {
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "classify",
+        input: value,
+        model,
+        options,
+        generateResponse: async (options) => {
+            const result = await model.doClassify(value, options);
+            return {
+                rawResponse: result.rawResponse,
+                extractedValue: result.class,
+            };
+        },
+    });
+    return fullResponse
+        ? {
+            class: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
+        }
+        : callResponse.value;
+}
+exports.classify = classify;

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

@@ -0,0 +1,17 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
+import { Classifier, ClassifierSettings } from "./Classifier.js";
+export declare function classify<VALUE, CLASS extends string | null>(args: {
+    model: Classifier<VALUE, CLASS, ClassifierSettings>;
+    value: VALUE;
+    fullResponse?: false;
+} & FunctionOptions): Promise<CLASS>;
+export declare function classify<VALUE, CLASS extends string | null>(args: {
+    model: Classifier<VALUE, CLASS, ClassifierSettings>;
+    value: VALUE;
+    fullResponse: true;
+} & FunctionOptions): Promise<{
+    class: CLASS;
+    rawResponse: unknown;
+    metadata: ModelCallMetadata;
+}>;

package/model-function/classify/classify.js

@@ -0,0 +1,23 @@
+import { executeStandardCall } from "../executeStandardCall.js";
+export async function classify({ model, value, fullResponse, ...options }) {
+    const callResponse = await executeStandardCall({
+        functionType: "classify",
+        input: value,
+        model,
+        options,
+        generateResponse: async (options) => {
+            const result = await model.doClassify(value, options);
+            return {
+                rawResponse: result.rawResponse,
+                extractedValue: result.class,
+            };
+        },
+    });
+    return fullResponse
+        ? {
+            class: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
+        }
+        : callResponse.value;
+}

package/{classifier → model-function/classify}/index.cjs

@@ -14,4 +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("./SemanticClassifier.cjs"), exports);
+__exportStar(require("./Classifier.cjs"), exports);
+__exportStar(require("./ClassifyEvent.cjs"), exports);
+__exportStar(require("./EmbeddingSimilarityClassifier.cjs"), exports);
+__exportStar(require("./classify.cjs"), exports);

package/model-function/classify/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Classifier.js";
+export * from "./ClassifyEvent.js";
+export * from "./EmbeddingSimilarityClassifier.js";
+export * from "./classify.js";

package/model-function/classify/index.js

@@ -0,0 +1,4 @@
+export * from "./Classifier.js";
+export * from "./ClassifyEvent.js";
+export * from "./EmbeddingSimilarityClassifier.js";
+export * from "./classify.js";

package/model-function/embed/embed.cjs

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.embed = exports.embedMany = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-async function embedMany(model, values, options) {
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+async function embedMany({ model, values, fullResponse, ...options }) {
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "embed",
         input: values,
         model,
@@ -43,17 +43,17 @@ async function embedMany(model, values, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            embeddings: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            embeddings: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.embedMany = embedMany;
-async function embed(model, value, options) {
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+async function embed({ model, value, fullResponse, ...options }) {
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "embed",
         input: value,
         model,
@@ -66,12 +66,12 @@ async function embed(model, value, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            embedding: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            embedding: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.embed = embed;

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

@@ -8,26 +8,29 @@ import { EmbeddingModel, EmbeddingModelSettings } from "./EmbeddingModel.js";
  * @see https://modelfusion.dev/guide/function/embed
  *
  * @example
- * const embeddings = await embedMany(
- *   openai.TextEmbedder(...),
- *   [
+ * const embeddings = await embedMany({
+ *   embedder: openai.TextEmbedder(...),
+ *   values: [
  *     "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 {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 & {
+export declare function embedMany<VALUE>(args: {
+    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
+    values: VALUE[];
     fullResponse?: false;
-}): Promise<Vector[]>;
-export declare function embedMany<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, values: VALUE[], options: FunctionOptions & {
+} & FunctionOptions): Promise<Vector[]>;
+export declare function embedMany<VALUE>(args: {
+    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
+    values: VALUE[];
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     embeddings: Vector[];
     rawResponse: unknown;
     metadata: ModelCallMetadata;
@@ -38,23 +41,26 @@ export declare function embedMany<VALUE>(model: EmbeddingModel<VALUE, EmbeddingM
  * @see https://modelfusion.dev/guide/function/embed
  *
  * @example
- * const embedding = await embed(
- *   openai.TextEmbedder(...),
- *   "At first, Nox didn't know what to do with the pup."
- * );
+ * const embedding = await embed({
+ *   model: openai.TextEmbedder(...),
+ *   value: "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 {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 & {
+export declare function embed<VALUE>(args: {
+    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
+    value: VALUE;
     fullResponse?: false;
-}): Promise<Vector>;
-export declare function embed<VALUE>(model: EmbeddingModel<VALUE, EmbeddingModelSettings>, value: VALUE, options: FunctionOptions & {
+} & FunctionOptions): Promise<Vector>;
+export declare function embed<VALUE>(args: {
+    model: EmbeddingModel<VALUE, EmbeddingModelSettings>;
+    value: VALUE;
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     embedding: Vector;
     rawResponse: unknown;
     metadata: ModelCallMetadata;

package/model-function/embed/embed.js

@@ -1,6 +1,6 @@
 import { executeStandardCall } from "../executeStandardCall.js";
-export async function embedMany(model, values, options) {
-    const fullResponse = await executeStandardCall({
+export async function embedMany({ model, values, fullResponse, ...options }) {
+    const callResponse = await executeStandardCall({
         functionType: "embed",
         input: values,
         model,
@@ -40,16 +40,16 @@ export async function embedMany(model, values, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            embeddings: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            embeddings: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
-export async function embed(model, value, options) {
-    const fullResponse = await executeStandardCall({
+export async function embed({ model, value, fullResponse, ...options }) {
+    const callResponse = await executeStandardCall({
         functionType: "embed",
         input: value,
         model,
@@ -62,11 +62,11 @@ export async function embed(model, value, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            embedding: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            embedding: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateImage = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-async function generateImage(model, prompt, options) {
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+async function generateImage({ model, prompt, fullResponse, ...options }) {
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-image",
         input: prompt,
         model,
@@ -16,16 +16,16 @@ async function generateImage(model, prompt, options) {
             };
         },
     });
-    const imagesBase64 = fullResponse.value;
+    const imagesBase64 = callResponse.value;
     const images = imagesBase64.map((imageBase64) => Buffer.from(imageBase64, "base64"));
-    return options?.fullResponse
+    return fullResponse
         ? {
             image: images[0],
             imageBase64: imagesBase64[0],
             images,
             imagesBase64,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
         : images[0];
 }

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

@@ -11,27 +11,30 @@ import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGener
  * @see https://modelfusion.dev/guide/function/generate-image
  *
  * @example
- * const image = await generateImage(
- *   stability.ImageGenerator(...),
- *   [
+ * const image = await generateImage({
+ *   imageGenerator: stability.ImageGenerator(...),
+ *   prompt: [
  *     { 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 {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 & {
+export declare function generateImage<PROMPT>(args: {
+    model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>;
+    prompt: PROMPT;
     fullResponse?: false;
-}): Promise<Buffer>;
-export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options: FunctionOptions & {
+} & FunctionOptions): Promise<Buffer>;
+export declare function generateImage<PROMPT>(args: {
+    model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>;
+    prompt: PROMPT;
     fullResponse: true;
-}): Promise<{
+} & FunctionOptions): Promise<{
     image: Buffer;
     imageBase64: string;
     images: Buffer[];

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

@@ -1,6 +1,6 @@
 import { executeStandardCall } from "../executeStandardCall.js";
-export async function generateImage(model, prompt, options) {
-    const fullResponse = await executeStandardCall({
+export async function generateImage({ model, prompt, fullResponse, ...options }) {
+    const callResponse = await executeStandardCall({
         functionType: "generate-image",
         input: prompt,
         model,
@@ -13,16 +13,16 @@ export async function generateImage(model, prompt, options) {
             };
         },
     });
-    const imagesBase64 = fullResponse.value;
+    const imagesBase64 = callResponse.value;
     const images = imagesBase64.map((imageBase64) => Buffer.from(imageBase64, "base64"));
-    return options?.fullResponse
+    return fullResponse
         ? {
             image: images[0],
             imageBase64: imagesBase64[0],
             images,
             imagesBase64,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
         : images[0];
 }

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSpeech = void 0;
 const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-async function generateSpeech(model, text, options) {
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+async function generateSpeech({ model, text, fullResponse, ...options }) {
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-speech",
         input: text,
         model,
@@ -16,12 +16,12 @@ async function generateSpeech(model, text, options) {
             };
         },
     });
-    return options?.fullResponse
+    return fullResponse
         ? {
-            speech: fullResponse.value,
-            rawResponse: fullResponse.rawResponse,
-            metadata: fullResponse.metadata,
+            speech: callResponse.value,
+            rawResponse: callResponse.rawResponse,
+            metadata: callResponse.metadata,
         }
-        : fullResponse.value;
+        : callResponse.value;
 }
 exports.generateSpeech = generateSpeech;