modelfusion 0.110.0 → 0.112.0

package/model-provider/elevenlabs/ElevenLabsSpeechModel.js

@@ -1,13 +1,12 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
-import { createAudioMpegResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
+import { createAudioMpegResponseHandler, createTextErrorResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+import { safeParseJSON } from "../../core/schema/parseJSON.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { createSimpleWebSocket } from "../../util/SimpleWebSocket.js";
-import { safeParseJSON } from "../../core/schema/parseJSON.js";
 import { ElevenLabsApiConfiguration } from "./ElevenLabsApiConfiguration.js";
-import { failedElevenLabsCallResponseHandler } from "./ElevenLabsError.js";
 const elevenLabsModels = [
     "eleven_multilingual_v2",
     "eleven_multilingual_v1",
@@ -15,27 +14,6 @@ const elevenLabsModels = [
     "eleven_turbo_v2",
 ];
 const defaultModel = "eleven_monolingual_v1";
-const streamingResponseSchema = new ZodSchema(z.union([
-    z.object({
-        audio: z.string(),
-        isFinal: z.literal(false).nullable(),
-        normalizedAlignment: z
-            .object({
-            chars: z.array(z.string()),
-            charStartTimesMs: z.array(z.number()),
-            charDurationsMs: z.array(z.number()),
-        })
-            .nullable(),
-    }),
-    z.object({
-        isFinal: z.literal(true),
-    }),
-    z.object({
-        message: z.string(),
-        error: z.string(),
-        code: z.number(),
-    }),
-]));
 /**
  * Synthesize speech using the ElevenLabs Text to Speech API.
  *
@@ -58,16 +36,25 @@ export class ElevenLabsSpeechModel extends AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
+        const api = this.settings.api ?? new ElevenLabsApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return callWithRetryAndThrottle({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callElevenLabsTextToSpeechAPI({
-                api: this.settings.api,
-                abortSignal: options?.run?.abortSignal,
-                text,
-                voiceId: this.settings.voice,
-                modelId: this.settings.model,
-                voiceSettings: this.settings.voiceSettings,
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => postJsonToApi({
+                url: api.assembleUrl(`/text-to-speech/${this.settings.voice}${assembleQuery({
+                    optimize_streaming_latency: this.settings.optimizeStreamingLatency,
+                    output_format: this.settings.outputFormat,
+                })}`),
+                headers: api.headers,
+                body: {
+                    text,
+                    model_id: this.settings.model ?? defaultModel,
+                    voice_settings: toApiVoiceSettings(this.settings.voiceSettings),
+                },
+                failedResponseHandler: createTextErrorResponseHandler(),
+                successfulResponseHandler: createAudioMpegResponseHandler(),
+                abortSignal,
             }),
         });
     }
@@ -132,7 +119,7 @@ export class ElevenLabsSpeechModel extends AbstractModel {
         socket.onmessage = (event) => {
             const parseResult = safeParseJSON({
                 text: event.data,
-                schema: streamingResponseSchema,
+                schema: zodSchema(streamingResponseSchema),
             });
             if (!parseResult.success) {
                 queue.push({ type: "error", error: parseResult.error });
@@ -165,23 +152,27 @@ export class ElevenLabsSpeechModel extends AbstractModel {
         });
     }
 }
-async function callElevenLabsTextToSpeechAPI({ api = new ElevenLabsApiConfiguration(), abortSignal, text, voiceId, modelId, optimizeStreamingLatency, outputFormat, voiceSettings, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/text-to-speech/${voiceId}${assembleQuery({
-            optimize_streaming_latency: optimizeStreamingLatency,
-            output_format: outputFormat,
-        })}`),
-        headers: api.headers,
-        body: {
-            text,
-            model_id: modelId ?? defaultModel,
-            voice_settings: toApiVoiceSettings(voiceSettings),
-        },
-        failedResponseHandler: failedElevenLabsCallResponseHandler,
-        successfulResponseHandler: createAudioMpegResponseHandler(),
-        abortSignal,
-    });
-}
+const streamingResponseSchema = z.union([
+    z.object({
+        audio: z.string(),
+        isFinal: z.literal(false).nullable(),
+        normalizedAlignment: z
+            .object({
+            chars: z.array(z.string()),
+            charStartTimesMs: z.array(z.number()),
+            charDurationsMs: z.array(z.number()),
+        })
+            .nullable(),
+    }),
+    z.object({
+        isFinal: z.literal(true),
+    }),
+    z.object({
+        message: z.string(),
+        error: z.string(),
+        code: z.number(),
+    }),
+]);
 function assembleQuery(parameters) {
     let query = "";
     let hasQuestionMark = false;
@@ -212,8 +203,6 @@ function toApiVoiceSettings(voiceSettings) {
 }
 function toGenerationConfig(generationConfig) {
     return generationConfig != null
-        ? {
-            chunk_length_schedule: generationConfig.chunkLengthSchedule,
-        }
+        ? { chunk_length_schedule: generationConfig.chunkLengthSchedule }
         : undefined;
 }

package/model-provider/huggingface/HuggingFaceApiConfiguration.cjs

@@ -3,19 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HuggingFaceApiConfiguration = void 0;
 const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
 const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
-class HuggingFaceApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api-inference.huggingface.co/models", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the HuggingFace API.
+ * It calls the API at https://api-inference.huggingface.co/models and uses the `HUGGINGFACE_API_KEY` env variable by default.
+ */
+class HuggingFaceApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
+            ...settings,
             headers: {
                 Authorization: `Bearer ${(0, loadApiKey_js_1.loadApiKey)({
-                    apiKey,
+                    apiKey: settings.apiKey,
                     environmentVariableName: "HUGGINGFACE_API_KEY",
                     description: "Hugging Face",
                 })}`,
             },
-            retry,
-            throttle,
+            baseUrlDefaults: {
+                protocol: "https",
+                host: "api-inference.huggingface.co",
+                port: "443",
+                path: "/models",
+            },
         });
     }
 }

package/model-provider/huggingface/HuggingFaceApiConfiguration.d.ts

@@ -1,11 +1,10 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
-import { RetryFunction } from "../../core/api/RetryFunction.js";
-import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
-export declare class HuggingFaceApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl, apiKey, retry, throttle, }?: {
-        baseUrl?: string;
+import { BaseUrlApiConfigurationWithDefaults, PartialBaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlApiConfiguration.js";
+/**
+ * Creates an API configuration for the HuggingFace API.
+ * It calls the API at https://api-inference.huggingface.co/models and uses the `HUGGINGFACE_API_KEY` env variable by default.
+ */
+export declare class HuggingFaceApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings?: PartialBaseUrlPartsApiConfigurationOptions & {
         apiKey?: string;
-        retry?: RetryFunction;
-        throttle?: ThrottleFunction;
     });
 }

package/model-provider/huggingface/HuggingFaceApiConfiguration.js

@@ -1,18 +1,26 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { BaseUrlApiConfigurationWithDefaults, } from "../../core/api/BaseUrlApiConfiguration.js";
 import { loadApiKey } from "../../core/api/loadApiKey.js";
-export class HuggingFaceApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api-inference.huggingface.co/models", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the HuggingFace API.
+ * It calls the API at https://api-inference.huggingface.co/models and uses the `HUGGINGFACE_API_KEY` env variable by default.
+ */
+export class HuggingFaceApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
+            ...settings,
             headers: {
                 Authorization: `Bearer ${loadApiKey({
-                    apiKey,
+                    apiKey: settings.apiKey,
                     environmentVariableName: "HUGGINGFACE_API_KEY",
                     description: "Hugging Face",
                 })}`,
             },
-            retry,
-            throttle,
+            baseUrlDefaults: {
+                protocol: "https",
+                host: "api-inference.huggingface.co",
+                port: "443",
+                path: "/models",
+            },
         });
     }
 }

package/model-provider/huggingface/HuggingFaceError.cjs

@@ -1,35 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.failedHuggingFaceCallResponseHandler = exports.HuggingFaceError = exports.huggingFaceErrorDataSchema = void 0;
+exports.failedHuggingFaceCallResponseHandler = void 0;
 const zod_1 = require("zod");
-const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
-const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-exports.huggingFaceErrorDataSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
+const huggingFaceErrorDataSchema = zod_1.z.object({
     error: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()),
-}));
-class HuggingFaceError extends ApiCallError_js_1.ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = typeof data.error === "string"
-        ? data.error
-        : data.error.join("\n\n"), }) {
-        super({ message, statusCode, requestBodyValues, url });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.data = data;
-    }
-}
-exports.HuggingFaceError = HuggingFaceError;
-const failedHuggingFaceCallResponseHandler = async ({ response, url, requestBodyValues }) => new HuggingFaceError({
-    url,
-    requestBodyValues,
-    statusCode: response.status,
-    data: (0, parseJSON_js_1.parseJSON)({
-        text: await response.text(),
-        schema: exports.huggingFaceErrorDataSchema,
-    }),
 });
-exports.failedHuggingFaceCallResponseHandler = failedHuggingFaceCallResponseHandler;
+exports.failedHuggingFaceCallResponseHandler = (0, postToApi_js_1.createJsonErrorResponseHandler)({
+    errorSchema: (0, ZodSchema_js_1.zodSchema)(huggingFaceErrorDataSchema),
+    errorToMessage: (data) => typeof data.error === "string" ? data.error : data.error.join("\n\n"),
+});

package/model-provider/huggingface/HuggingFaceError.d.ts

@@ -1,18 +1,11 @@
-import { ApiCallError } from "../../core/api/ApiCallError.js";
-import { ResponseHandler } from "../../core/api/postToApi.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
-export declare const huggingFaceErrorDataSchema: ZodSchema<{
+import { z } from "zod";
+declare const huggingFaceErrorDataSchema: z.ZodObject<{
+    error: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    error: (string | string[]) & (string | string[] | undefined);
+}, {
     error: (string | string[]) & (string | string[] | undefined);
 }>;
-export type HuggingFaceErrorData = (typeof huggingFaceErrorDataSchema)["_type"];
-export declare class HuggingFaceError extends ApiCallError {
-    readonly data: HuggingFaceErrorData;
-    constructor({ data, statusCode, url, requestBodyValues, message, }: {
-        message?: string;
-        statusCode: number;
-        url: string;
-        requestBodyValues: unknown;
-        data: HuggingFaceErrorData;
-    });
-}
-export declare const failedHuggingFaceCallResponseHandler: ResponseHandler<ApiCallError>;
+export type HuggingFaceErrorData = z.infer<typeof huggingFaceErrorDataSchema>;
+export declare const failedHuggingFaceCallResponseHandler: import("../../core/api/postToApi.js").ResponseHandler<import("../../index.js").ApiCallError>;
+export {};

package/model-provider/huggingface/HuggingFaceError.js

@@ -1,30 +1,10 @@
 import { z } from "zod";
-import { ApiCallError } from "../../core/api/ApiCallError.js";
-import { parseJSON } from "../../core/schema/parseJSON.js";
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
-export const huggingFaceErrorDataSchema = new ZodSchema(z.object({
+import { createJsonErrorResponseHandler } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+const huggingFaceErrorDataSchema = z.object({
     error: z.array(z.string()).or(z.string()),
-}));
-export class HuggingFaceError extends ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = typeof data.error === "string"
-        ? data.error
-        : data.error.join("\n\n"), }) {
-        super({ message, statusCode, requestBodyValues, url });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.data = data;
-    }
-}
-export const failedHuggingFaceCallResponseHandler = async ({ response, url, requestBodyValues }) => new HuggingFaceError({
-    url,
-    requestBodyValues,
-    statusCode: response.status,
-    data: parseJSON({
-        text: await response.text(),
-        schema: huggingFaceErrorDataSchema,
-    }),
+});
+export const failedHuggingFaceCallResponseHandler = createJsonErrorResponseHandler({
+    errorSchema: zodSchema(huggingFaceErrorDataSchema),
+    errorToMessage: (data) => typeof data.error === "string" ? data.error : data.error.join("\n\n"),
 });

package/model-provider/huggingface/HuggingFaceFacade.cjs

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextEmbedder = exports.TextGenerator = void 0;
+exports.TextEmbedder = exports.TextGenerator = exports.Api = void 0;
+const HuggingFaceApiConfiguration_js_1 = require("./HuggingFaceApiConfiguration.cjs");
 const HuggingFaceTextEmbeddingModel_js_1 = require("./HuggingFaceTextEmbeddingModel.cjs");
 const HuggingFaceTextGenerationModel_js_1 = require("./HuggingFaceTextGenerationModel.cjs");
+/**
+ * Creates an API configuration for the HuggingFace API.
+ * It calls the API at https://api-inference.huggingface.co/models and uses the `HUGGINGFACE_API_KEY` env variable by default.
+ */
+function Api(settings) {
+    return new HuggingFaceApiConfiguration_js_1.HuggingFaceApiConfiguration(settings);
+}
+exports.Api = Api;
 /**
  * Create a text generation model that calls a Hugging Face Inference API Text Generation Task.
  *

package/model-provider/huggingface/HuggingFaceFacade.d.ts

@@ -1,5 +1,14 @@
+import { PartialBaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlApiConfiguration.js";
+import { HuggingFaceApiConfiguration } from "./HuggingFaceApiConfiguration.js";
 import { HuggingFaceTextEmbeddingModel, HuggingFaceTextEmbeddingModelSettings } from "./HuggingFaceTextEmbeddingModel.js";
 import { HuggingFaceTextGenerationModel, HuggingFaceTextGenerationModelSettings } from "./HuggingFaceTextGenerationModel.js";
+/**
+ * Creates an API configuration for the HuggingFace API.
+ * It calls the API at https://api-inference.huggingface.co/models and uses the `HUGGINGFACE_API_KEY` env variable by default.
+ */
+export declare function Api(settings: PartialBaseUrlPartsApiConfigurationOptions & {
+    apiKey?: string;
+}): HuggingFaceApiConfiguration;
 /**
  * Create a text generation model that calls a Hugging Face Inference API Text Generation Task.
  *

package/model-provider/huggingface/HuggingFaceFacade.js

@@ -1,5 +1,13 @@
+import { HuggingFaceApiConfiguration } from "./HuggingFaceApiConfiguration.js";
 import { HuggingFaceTextEmbeddingModel, } from "./HuggingFaceTextEmbeddingModel.js";
 import { HuggingFaceTextGenerationModel, } from "./HuggingFaceTextGenerationModel.js";
+/**
+ * Creates an API configuration for the HuggingFace API.
+ * It calls the API at https://api-inference.huggingface.co/models and uses the `HUGGINGFACE_API_KEY` env variable by default.
+ */
+export function Api(settings) {
+    return new HuggingFaceApiConfiguration(settings);
+}
 /**
  * Create a text generation model that calls a Hugging Face Inference API Text Generation Task.
  *

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.cjs

@@ -4,6 +4,7 @@ exports.HuggingFaceTextEmbeddingModel = void 0;
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const HuggingFaceApiConfiguration_js_1 = require("./HuggingFaceApiConfiguration.cjs");
 const HuggingFaceError_js_1 = require("./HuggingFaceError.cjs");
@@ -83,17 +84,24 @@ class HuggingFaceTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The HuggingFace feature extraction API is configured to only support ${this.maxValuesPerCall} texts per API call.`);
         }
+        const api = this.settings.api ?? new HuggingFaceApiConfiguration_js_1.HuggingFaceApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callHuggingFaceTextGenerationAPI({
-                options: {
-                    useCache: true,
-                    waitForModel: true,
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => (0, postToApi_js_1.postJsonToApi)({
+                url: api.assembleUrl(`/${this.settings.model}`),
+                headers: api.headers,
+                body: {
+                    inputs: texts,
+                    options: {
+                        use_cache: this.settings.options?.useCache ?? true,
+                        wait_for_model: this.settings.options?.waitForModel ?? true,
+                    },
                 },
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                inputs: texts,
+                failedResponseHandler: HuggingFaceError_js_1.failedHuggingFaceCallResponseHandler,
+                successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(huggingFaceTextEmbeddingResponseSchema)),
+                abortSignal,
             }),
         });
     }
@@ -116,21 +124,3 @@ class HuggingFaceTextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
 }
 exports.HuggingFaceTextEmbeddingModel = HuggingFaceTextEmbeddingModel;
 const huggingFaceTextEmbeddingResponseSchema = zod_1.z.array(zod_1.z.array(zod_1.z.number()));
-async function callHuggingFaceTextGenerationAPI({ api = new HuggingFaceApiConfiguration_js_1.HuggingFaceApiConfiguration(), abortSignal, model, inputs, options, }) {
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl(`/${model}`),
-        headers: api.headers,
-        body: {
-            inputs,
-            options: options
-                ? {
-                    use_cache: options?.useCache,
-                    wait_for_model: options?.waitForModel,
-                }
-                : {},
-        },
-        failedResponseHandler: HuggingFaceError_js_1.failedHuggingFaceCallResponseHandler,
-        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(huggingFaceTextEmbeddingResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/huggingface/HuggingFaceTextEmbeddingModel.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { HuggingFaceApiConfiguration } from "./HuggingFaceApiConfiguration.js";
 import { failedHuggingFaceCallResponseHandler } from "./HuggingFaceError.js";
@@ -80,17 +81,24 @@ export class HuggingFaceTextEmbeddingModel extends AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The HuggingFace feature extraction API is configured to only support ${this.maxValuesPerCall} texts per API call.`);
         }
+        const api = this.settings.api ?? new HuggingFaceApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return callWithRetryAndThrottle({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callHuggingFaceTextGenerationAPI({
-                options: {
-                    useCache: true,
-                    waitForModel: true,
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => postJsonToApi({
+                url: api.assembleUrl(`/${this.settings.model}`),
+                headers: api.headers,
+                body: {
+                    inputs: texts,
+                    options: {
+                        use_cache: this.settings.options?.useCache ?? true,
+                        wait_for_model: this.settings.options?.waitForModel ?? true,
+                    },
                 },
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                inputs: texts,
+                failedResponseHandler: failedHuggingFaceCallResponseHandler,
+                successfulResponseHandler: createJsonResponseHandler(zodSchema(huggingFaceTextEmbeddingResponseSchema)),
+                abortSignal,
             }),
         });
     }
@@ -112,21 +120,3 @@ export class HuggingFaceTextEmbeddingModel extends AbstractModel {
     }
 }
 const huggingFaceTextEmbeddingResponseSchema = z.array(z.array(z.number()));
-async function callHuggingFaceTextGenerationAPI({ api = new HuggingFaceApiConfiguration(), abortSignal, model, inputs, options, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/${model}`),
-        headers: api.headers,
-        body: {
-            inputs,
-            options: options
-                ? {
-                    use_cache: options?.useCache,
-                    wait_for_model: options?.waitForModel,
-                }
-                : {},
-        },
-        failedResponseHandler: failedHuggingFaceCallResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler(huggingFaceTextEmbeddingResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/huggingface/HuggingFaceTextGenerationModel.cjs

@@ -4,6 +4,7 @@ exports.HuggingFaceTextGenerationModel = void 0;
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptTemplateTextGenerationModel_js_1 = require("../../model-function/generate-text/PromptTemplateTextGenerationModel.cjs");
 const TextGenerationModel_js_1 = require("../../model-function/generate-text/TextGenerationModel.cjs");
@@ -64,30 +65,28 @@ class HuggingFaceTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
-            call: async () => {
-                return (0, postToApi_js_1.postJsonToApi)({
-                    url: api.assembleUrl(`/${this.settings.model}`),
-                    headers: api.headers,
-                    body: {
-                        inputs: prompt,
-                        top_k: this.settings.topK,
-                        top_p: this.settings.topP,
-                        temperature: this.settings.temperature,
-                        repetition_penalty: this.settings.repetitionPenalty,
-                        max_new_tokens: this.settings.maxGenerationTokens,
-                        max_time: this.settings.maxTime,
-                        num_return_sequences: this.settings.numberOfGenerations,
-                        do_sample: this.settings.doSample,
-                        options: {
-                            use_cache: true,
-                            wait_for_model: true,
-                        },
+            call: async () => (0, postToApi_js_1.postJsonToApi)({
+                url: api.assembleUrl(`/${this.settings.model}`),
+                headers: api.headers,
+                body: {
+                    inputs: prompt,
+                    top_k: this.settings.topK,
+                    top_p: this.settings.topP,
+                    temperature: this.settings.temperature,
+                    repetition_penalty: this.settings.repetitionPenalty,
+                    max_new_tokens: this.settings.maxGenerationTokens,
+                    max_time: this.settings.maxTime,
+                    num_return_sequences: this.settings.numberOfGenerations,
+                    do_sample: this.settings.doSample,
+                    options: {
+                        use_cache: true,
+                        wait_for_model: true,
                     },
-                    failedResponseHandler: HuggingFaceError_js_1.failedHuggingFaceCallResponseHandler,
-                    successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(huggingFaceTextGenerationResponseSchema),
-                    abortSignal,
-                });
-            },
+                },
+                failedResponseHandler: HuggingFaceError_js_1.failedHuggingFaceCallResponseHandler,
+                successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(huggingFaceTextGenerationResponseSchema)),
+                abortSignal,
+            }),
         });
     }
     get settingsForEvent() {

package/model-provider/huggingface/HuggingFaceTextGenerationModel.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptTemplateTextGenerationModel } from "../../model-function/generate-text/PromptTemplateTextGenerationModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
@@ -61,30 +62,28 @@ export class HuggingFaceTextGenerationModel extends AbstractModel {
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
-            call: async () => {
-                return postJsonToApi({
-                    url: api.assembleUrl(`/${this.settings.model}`),
-                    headers: api.headers,
-                    body: {
-                        inputs: prompt,
-                        top_k: this.settings.topK,
-                        top_p: this.settings.topP,
-                        temperature: this.settings.temperature,
-                        repetition_penalty: this.settings.repetitionPenalty,
-                        max_new_tokens: this.settings.maxGenerationTokens,
-                        max_time: this.settings.maxTime,
-                        num_return_sequences: this.settings.numberOfGenerations,
-                        do_sample: this.settings.doSample,
-                        options: {
-                            use_cache: true,
-                            wait_for_model: true,
-                        },
+            call: async () => postJsonToApi({
+                url: api.assembleUrl(`/${this.settings.model}`),
+                headers: api.headers,
+                body: {
+                    inputs: prompt,
+                    top_k: this.settings.topK,
+                    top_p: this.settings.topP,
+                    temperature: this.settings.temperature,
+                    repetition_penalty: this.settings.repetitionPenalty,
+                    max_new_tokens: this.settings.maxGenerationTokens,
+                    max_time: this.settings.maxTime,
+                    num_return_sequences: this.settings.numberOfGenerations,
+                    do_sample: this.settings.doSample,
+                    options: {
+                        use_cache: true,
+                        wait_for_model: true,
                     },
-                    failedResponseHandler: failedHuggingFaceCallResponseHandler,
-                    successfulResponseHandler: createJsonResponseHandler(huggingFaceTextGenerationResponseSchema),
-                    abortSignal,
-                });
-            },
+                },
+                failedResponseHandler: failedHuggingFaceCallResponseHandler,
+                successfulResponseHandler: createJsonResponseHandler(zodSchema(huggingFaceTextGenerationResponseSchema)),
+                abortSignal,
+            }),
         });
     }
     get settingsForEvent() {