@huggingface/inference 3.0.1 → 3.1.0

package/dist/index.cjs

@@ -119,6 +119,10 @@ var FAL_AI_SUPPORTED_MODEL_IDS = {
   },
   "automatic-speech-recognition": {
     "openai/whisper-large-v3": "fal-ai/whisper"
+  },
+  "text-to-video": {
+    "genmo/mochi-1-preview": "fal-ai/mochi-v1",
+    "tencent/HunyuanVideo": "fal-ai/hunyuan-video"
   }
 };
 
@@ -131,6 +135,9 @@ var REPLICATE_SUPPORTED_MODEL_IDS = {
   },
   "text-to-speech": {
     "OuteAI/OuteTTS-0.3-500M": "jbilcke/oute-tts:39a59319327b27327fa3095149c5a746e7f2aee18c75055c3368237a6503cd26"
+  },
+  "text-to-video": {
+    "genmo/mochi-1-preview": "genmoai/mochi-1:1944af04d098ef69bed7f9d335d102e652203f268ec4aaa2d836f6217217e460"
   }
 };
 
@@ -596,9 +603,42 @@ var InferenceOutputError = class extends TypeError {
   }
 };
 
+// src/utils/pick.ts
+function pick(o, props) {
+  return Object.assign(
+    {},
+    ...props.map((prop) => {
+      if (o[prop] !== void 0) {
+        return { [prop]: o[prop] };
+      }
+    })
+  );
+}
+
+// src/utils/typedInclude.ts
+function typedInclude(arr, v) {
+  return arr.includes(v);
+}
+
+// src/utils/omit.ts
+function omit(o, props) {
+  const propsArr = Array.isArray(props) ? props : [props];
+  const letsKeep = Object.keys(o).filter((prop) => !typedInclude(propsArr, prop));
+  return pick(o, letsKeep);
+}
+
+// src/tasks/audio/utils.ts
+function preparePayload(args) {
+  return "data" in args ? args : {
+    ...omit(args, "inputs"),
+    data: args.inputs
+  };
+}
+
 // src/tasks/audio/audioClassification.ts
 async function audioClassification(args, options) {
-  const res = await request(args, {
+  const payload = preparePayload(args);
+  const res = await request(payload, {
     ...options,
     taskHint: "audio-classification"
   });
@@ -624,15 +664,8 @@ function base64FromBytes(arr) {
 
 // src/tasks/audio/automaticSpeechRecognition.ts
 async function automaticSpeechRecognition(args, options) {
-  if (args.provider === "fal-ai") {
-    const contentType = args.data instanceof Blob ? args.data.type : "audio/mpeg";
-    const base64audio = base64FromBytes(
-      new Uint8Array(args.data instanceof ArrayBuffer ? args.data : await args.data.arrayBuffer())
-    );
-    args.audio_url = `data:${contentType};base64,${base64audio}`;
-    delete args.data;
-  }
-  const res = await request(args, {
+  const payload = await buildPayload(args);
+  const res = await request(payload, {
     ...options,
     taskHint: "automatic-speech-recognition"
   });
@@ -642,6 +675,32 @@ async function automaticSpeechRecognition(args, options) {
   }
   return res;
 }
+var FAL_AI_SUPPORTED_BLOB_TYPES = ["audio/mpeg", "audio/mp4", "audio/wav", "audio/x-wav"];
+async function buildPayload(args) {
+  if (args.provider === "fal-ai") {
+    const blob = "data" in args && args.data instanceof Blob ? args.data : "inputs" in args ? args.inputs : void 0;
+    const contentType = blob?.type;
+    if (!contentType) {
+      throw new Error(
+        `Unable to determine the input's content-type. Make sure your are passing a Blob when using provider fal-ai.`
+      );
+    }
+    if (!FAL_AI_SUPPORTED_BLOB_TYPES.includes(contentType)) {
+      throw new Error(
+        `Provider fal-ai does not support blob type ${contentType} - supported content types are: ${FAL_AI_SUPPORTED_BLOB_TYPES.join(
+          ", "
+        )}`
+      );
+    }
+    const base64audio = base64FromBytes(new Uint8Array(await blob.arrayBuffer()));
+    return {
+      ..."data" in args ? omit(args, "data") : omit(args, "inputs"),
+      audio_url: `data:${contentType};base64,${base64audio}`
+    };
+  } else {
+    return preparePayload(args);
+  }
+}
 
 // src/tasks/audio/textToSpeech.ts
 async function textToSpeech(args, options) {
@@ -649,6 +708,9 @@ async function textToSpeech(args, options) {
     ...options,
     taskHint: "text-to-speech"
   });
+  if (res instanceof Blob) {
+    return res;
+  }
   if (res && typeof res === "object") {
     if ("output" in res) {
       if (typeof res.output === "string") {
@@ -662,31 +724,39 @@ async function textToSpeech(args, options) {
       }
     }
   }
-  const isValidOutput = res && res instanceof Blob;
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Blob");
-  }
-  return res;
+  throw new InferenceOutputError("Expected Blob or object with output");
 }
 
 // src/tasks/audio/audioToAudio.ts
 async function audioToAudio(args, options) {
-  const res = await request(args, {
+  const payload = preparePayload(args);
+  const res = await request(payload, {
     ...options,
     taskHint: "audio-to-audio"
   });
-  const isValidOutput = Array.isArray(res) && res.every(
-    (x) => typeof x.label === "string" && typeof x.blob === "string" && typeof x["content-type"] === "string"
-  );
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{label: string, blob: string, content-type: string}>");
+  return validateOutput(res);
+}
+function validateOutput(output) {
+  if (!Array.isArray(output)) {
+    throw new InferenceOutputError("Expected Array");
   }
-  return res;
+  if (!output.every((elem) => {
+    return typeof elem === "object" && elem && "label" in elem && typeof elem.label === "string" && "content-type" in elem && typeof elem["content-type"] === "string" && "blob" in elem && typeof elem.blob === "string";
+  })) {
+    throw new InferenceOutputError("Expected Array<{label: string, audio: Blob}>");
+  }
+  return output;
+}
+
+// src/tasks/cv/utils.ts
+function preparePayload2(args) {
+  return "data" in args ? args : { ...omit(args, "inputs"), data: args.inputs };
 }
 
 // src/tasks/cv/imageClassification.ts
 async function imageClassification(args, options) {
-  const res = await request(args, {
+  const payload = preparePayload2(args);
+  const res = await request(payload, {
     ...options,
     taskHint: "image-classification"
   });
@@ -699,7 +769,8 @@ async function imageClassification(args, options) {
 
 // src/tasks/cv/imageSegmentation.ts
 async function imageSegmentation(args, options) {
-  const res = await request(args, {
+  const payload = preparePayload2(args);
+  const res = await request(payload, {
     ...options,
     taskHint: "image-segmentation"
   });
@@ -712,7 +783,8 @@ async function imageSegmentation(args, options) {
 
 // src/tasks/cv/imageToText.ts
 async function imageToText(args, options) {
-  const res = (await request(args, {
+  const payload = preparePayload2(args);
+  const res = (await request(payload, {
     ...options,
     taskHint: "image-to-text"
   }))?.[0];
@@ -724,7 +796,8 @@ async function imageToText(args, options) {
 
 // src/tasks/cv/objectDetection.ts
 async function objectDetection(args, options) {
-  const res = await request(args, {
+  const payload = preparePayload2(args);
+  const res = await request(payload, {
     ...options,
     taskHint: "object-detection"
   });
@@ -741,15 +814,13 @@ async function objectDetection(args, options) {
 
 // src/tasks/cv/textToImage.ts
 async function textToImage(args, options) {
-  if (args.provider === "together" || args.provider === "fal-ai") {
-    args.prompt = args.inputs;
-    delete args.inputs;
-    args.response_format = "base64";
-  } else if (args.provider === "replicate") {
-    args.prompt = args.inputs;
-    delete args.inputs;
-  }
-  const res = await request(args, {
+  const payload = args.provider === "together" || args.provider === "fal-ai" || args.provider === "replicate" ? {
+    ...omit(args, ["inputs", "parameters"]),
+    ...args.parameters,
+    ...args.provider !== "replicate" ? { response_format: "base64" } : void 0,
+    prompt: args.inputs
+  } : args;
+  const res = await request(payload, {
     ...options,
     taskHint: "text-to-image"
   });
@@ -806,18 +877,30 @@ async function imageToImage(args, options) {
 }
 
 // src/tasks/cv/zeroShotImageClassification.ts
-async function zeroShotImageClassification(args, options) {
-  const reqArgs = {
-    ...args,
-    inputs: {
-      image: base64FromBytes(
-        new Uint8Array(
-          args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
+async function preparePayload3(args) {
+  if (args.inputs instanceof Blob) {
+    return {
+      ...args,
+      inputs: {
+        image: base64FromBytes(new Uint8Array(await args.inputs.arrayBuffer()))
+      }
+    };
+  } else {
+    return {
+      ...args,
+      inputs: {
+        image: base64FromBytes(
+          new Uint8Array(
+            args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
+          )
         )
-      )
-    }
-  };
-  const res = await request(reqArgs, {
+      }
+    };
+  }
+}
+async function zeroShotImageClassification(args, options) {
+  const payload = await preparePayload3(args);
+  const res = await request(payload, {
     ...options,
     taskHint: "zero-shot-image-classification"
   });
@@ -906,17 +989,19 @@ async function questionAnswering(args, options) {
     ...options,
     taskHint: "question-answering"
   });
-  const isValidOutput = typeof res === "object" && !!res && typeof res.answer === "string" && typeof res.end === "number" && typeof res.score === "number" && typeof res.start === "number";
+  const isValidOutput = Array.isArray(res) ? res.every(
+    (elem) => typeof elem === "object" && !!elem && typeof elem.answer === "string" && typeof elem.end === "number" && typeof elem.score === "number" && typeof elem.start === "number"
+  ) : typeof res === "object" && !!res && typeof res.answer === "string" && typeof res.end === "number" && typeof res.score === "number" && typeof res.start === "number";
   if (!isValidOutput) {
-    throw new InferenceOutputError("Expected {answer: string, end: number, score: number, start: number}");
+    throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
   }
-  return res;
+  return Array.isArray(res) ? res[0] : res;
 }
 
 // src/tasks/nlp/sentenceSimilarity.ts
 async function sentenceSimilarity(args, options) {
   const defaultTask = args.model ? await getDefaultTask(args.model, args.accessToken, options) : void 0;
-  const res = await request(args, {
+  const res = await request(prepareInput(args), {
     ...options,
     taskHint: "sentence-similarity",
     ...defaultTask === "feature-extraction" && { forceTask: "sentence-similarity" }
@@ -927,6 +1012,13 @@ async function sentenceSimilarity(args, options) {
   }
   return res;
 }
+function prepareInput(args) {
+  return {
+    ...omit(args, ["inputs", "parameters"]),
+    inputs: { ...omit(args.inputs, "sourceSentence") },
+    parameters: { source_sentence: args.inputs.sourceSentence, ...args.parameters }
+  };
+}
 
 // src/tasks/nlp/summarization.ts
 async function summarization(args, options) {
@@ -947,13 +1039,18 @@ async function tableQuestionAnswering(args, options) {
     ...options,
     taskHint: "table-question-answering"
   });
-  const isValidOutput = typeof res?.aggregator === "string" && typeof res.answer === "string" && Array.isArray(res.cells) && res.cells.every((x) => typeof x === "string") && Array.isArray(res.coordinates) && res.coordinates.every((coord) => Array.isArray(coord) && coord.every((x) => typeof x === "number"));
+  const isValidOutput = Array.isArray(res) ? res.every((elem) => validate(elem)) : validate(res);
   if (!isValidOutput) {
     throw new InferenceOutputError(
       "Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}"
     );
   }
-  return res;
+  return Array.isArray(res) ? res[0] : res;
+}
+function validate(elem) {
+  return typeof elem === "object" && !!elem && "aggregator" in elem && typeof elem.aggregator === "string" && "answer" in elem && typeof elem.answer === "string" && "cells" in elem && Array.isArray(elem.cells) && elem.cells.every((x) => typeof x === "string") && "coordinates" in elem && Array.isArray(elem.coordinates) && elem.coordinates.every(
+    (coord) => Array.isArray(coord) && coord.every((x) => typeof x === "number")
+  );
 }
 
 // src/tasks/nlp/textClassification.ts
@@ -1096,11 +1193,7 @@ async function documentQuestionAnswering(args, options) {
     inputs: {
       question: args.inputs.question,
       // convert Blob or ArrayBuffer to base64
-      image: base64FromBytes(
-        new Uint8Array(
-          args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
-        )
-      )
+      image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer()))
     }
   };
   const res = toArray(
@@ -1108,12 +1201,14 @@ async function documentQuestionAnswering(args, options) {
       ...options,
       taskHint: "document-question-answering"
     })
-  )?.[0];
-  const isValidOutput = typeof res?.answer === "string" && (typeof res.end === "number" || typeof res.end === "undefined") && (typeof res.score === "number" || typeof res.score === "undefined") && (typeof res.start === "number" || typeof res.start === "undefined");
+  );
+  const isValidOutput = Array.isArray(res) && res.every(
+    (elem) => typeof elem === "object" && !!elem && typeof elem?.answer === "string" && (typeof elem.end === "number" || typeof elem.end === "undefined") && (typeof elem.score === "number" || typeof elem.score === "undefined") && (typeof elem.start === "number" || typeof elem.start === "undefined")
+  );
   if (!isValidOutput) {
     throw new InferenceOutputError("Expected Array<{answer: string, end?: number, score?: number, start?: number}>");
   }
-  return res;
+  return res[0];
 }
 
 // src/tasks/multimodal/visualQuestionAnswering.ts
@@ -1123,22 +1218,20 @@ async function visualQuestionAnswering(args, options) {
     inputs: {
       question: args.inputs.question,
       // convert Blob or ArrayBuffer to base64
-      image: base64FromBytes(
-        new Uint8Array(
-          args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
-        )
-      )
+      image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer()))
     }
   };
-  const res = (await request(reqArgs, {
+  const res = await request(reqArgs, {
     ...options,
     taskHint: "visual-question-answering"
-  }))?.[0];
-  const isValidOutput = typeof res?.answer === "string" && typeof res.score === "number";
+  });
+  const isValidOutput = Array.isArray(res) && res.every(
+    (elem) => typeof elem === "object" && !!elem && typeof elem?.answer === "string" && typeof elem.score === "number"
+  );
   if (!isValidOutput) {
     throw new InferenceOutputError("Expected Array<{answer: string, score: number}>");
   }
-  return res;
+  return res[0];
 }
 
 // src/tasks/tabular/tabularRegression.ts