@huggingface/inference 3.6.2 → 3.7.1

package/src/tasks/cv/textToImage.ts

@@ -1,48 +1,15 @@
-import type { TextToImageInput, TextToImageOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
-import type { BaseArgs, InferenceProvider, Options } from "../../types";
-import { omit } from "../../utils/omit";
-import { request } from "../custom/request";
-import { delay } from "../../utils/delay";
+import type { TextToImageInput } from "@huggingface/tasks";
+import { getProviderHelper } from "../../lib/getProviderHelper";
+import { makeRequestOptions } from "../../lib/makeRequestOptions";
+import type { BaseArgs, Options } from "../../types";
+import { innerRequest } from "../../utils/request";
 
 export type TextToImageArgs = BaseArgs & TextToImageInput;
 
-interface Base64ImageGeneration {
-	data: Array<{
-		b64_json: string;
-	}>;
-}
-interface OutputUrlImageGeneration {
-	output: string[];
-}
-interface HyperbolicTextToImageOutput {
-	images: Array<{ image: string }>;
-}
-
-interface BlackForestLabsResponse {
-	id: string;
-	polling_url: string;
-}
-
 interface TextToImageOptions extends Options {
 	outputType?: "url" | "blob";
 }
 
-function getResponseFormatArg(provider: InferenceProvider) {
-	switch (provider) {
-		case "fal-ai":
-			return { sync_mode: true };
-		case "nebius":
-			return { response_format: "b64_json" };
-		case "replicate":
-			return undefined;
-		case "together":
-			return { response_format: "base64" };
-		default:
-			return undefined;
-	}
-}
-
 /**
  * This task reads some text input and outputs an image.
  * Recommended model: stabilityai/stable-diffusion-2
@@ -56,108 +23,13 @@ export async function textToImage(
 	options?: TextToImageOptions & { outputType?: undefined | "blob" }
 ): Promise<Blob>;
 export async function textToImage(args: TextToImageArgs, options?: TextToImageOptions): Promise<Blob | string> {
-	const payload =
-		!args.provider || args.provider === "hf-inference" || args.provider === "sambanova"
-			? args
-			: {
-					...omit(args, ["inputs", "parameters"]),
-					...args.parameters,
-					...getResponseFormatArg(args.provider),
-					prompt: args.inputs,
-			  };
-	const res = await request<
-		| TextToImageOutput
-		| Base64ImageGeneration
-		| OutputUrlImageGeneration
-		| BlackForestLabsResponse
-		| HyperbolicTextToImageOutput
-	>(payload, {
+	const provider = args.provider ?? "hf-inference";
+	const providerHelper = getProviderHelper(provider, "text-to-image");
+	const { data: res } = await innerRequest<Record<string, unknown>>(args, {
 		...options,
 		task: "text-to-image",
 	});
 
-	if (res && typeof res === "object") {
-		if (args.provider === "black-forest-labs" && "polling_url" in res && typeof res.polling_url === "string") {
-			return await pollBflResponse(res.polling_url, options?.outputType);
-		}
-		if (args.provider === "fal-ai" && "images" in res && Array.isArray(res.images) && res.images[0].url) {
-			if (options?.outputType === "url") {
-				return res.images[0].url;
-			} else {
-				const image = await fetch(res.images[0].url);
-				return await image.blob();
-			}
-		}
-		if (
-			args.provider === "hyperbolic" &&
-			"images" in res &&
-			Array.isArray(res.images) &&
-			res.images[0] &&
-			typeof res.images[0].image === "string"
-		) {
-			if (options?.outputType === "url") {
-				return `data:image/jpeg;base64,${res.images[0].image}`;
-			}
-			const base64Response = await fetch(`data:image/jpeg;base64,${res.images[0].image}`);
-			return await base64Response.blob();
-		}
-		if ("data" in res && Array.isArray(res.data) && res.data[0].b64_json) {
-			const base64Data = res.data[0].b64_json;
-			if (options?.outputType === "url") {
-				return `data:image/jpeg;base64,${base64Data}`;
-			}
-			const base64Response = await fetch(`data:image/jpeg;base64,${base64Data}`);
-			return await base64Response.blob();
-		}
-		if ("output" in res && Array.isArray(res.output)) {
-			if (options?.outputType === "url") {
-				return res.output[0];
-			}
-			const urlResponse = await fetch(res.output[0]);
-			const blob = await urlResponse.blob();
-			return blob;
-		}
-	}
-	const isValidOutput = res && res instanceof Blob;
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected Blob");
-	}
-	if (options?.outputType === "url") {
-		const b64 = await res.arrayBuffer().then((buf) => Buffer.from(buf).toString("base64"));
-		return `data:image/jpeg;base64,${b64}`;
-	}
-	return res;
-}
-
-async function pollBflResponse(url: string, outputType?: "url" | "blob"): Promise<Blob> {
-	const urlObj = new URL(url);
-	for (let step = 0; step < 5; step++) {
-		await delay(1000);
-		console.debug(`Polling Black Forest Labs API for the result... ${step + 1}/5`);
-		urlObj.searchParams.set("attempt", step.toString(10));
-		const resp = await fetch(urlObj, { headers: { "Content-Type": "application/json" } });
-		if (!resp.ok) {
-			throw new InferenceOutputError("Failed to fetch result from black forest labs API");
-		}
-		const payload = await resp.json();
-		if (
-			typeof payload === "object" &&
-			payload &&
-			"status" in payload &&
-			typeof payload.status === "string" &&
-			payload.status === "Ready" &&
-			"result" in payload &&
-			typeof payload.result === "object" &&
-			payload.result &&
-			"sample" in payload.result &&
-			typeof payload.result.sample === "string"
-		) {
-			if (outputType === "url") {
-				return payload.result.sample;
-			}
-			const image = await fetch(payload.result.sample);
-			return await image.blob();
-		}
-	}
-	throw new InferenceOutputError("Failed to fetch result from black forest labs API");
+	const { url, info } = await makeRequestOptions(args, { ...options, task: "text-to-image" });
+	return providerHelper.getResponse(res, url, info.headers as Record<string, string>, options?.outputType);
 }

package/src/tasks/cv/textToVideo.ts

@@ -1,71 +1,23 @@
-import type { BaseArgs, InferenceProvider, Options } from "../../types";
 import type { TextToVideoInput } from "@huggingface/tasks";
-import { request } from "../custom/request";
-import { omit } from "../../utils/omit";
-import { isUrl } from "../../lib/isUrl";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
-import { typedInclude } from "../../utils/typedInclude";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import { makeRequestOptions } from "../../lib/makeRequestOptions";
-import { pollFalResponse, type FalAiQueueOutput } from "../../providers/fal-ai";
+import type { FalAiQueueOutput } from "../../providers/fal-ai";
+import type { NovitaOutput } from "../../providers/novita";
+import type { ReplicateOutput } from "../../providers/replicate";
+import type { BaseArgs, Options } from "../../types";
+import { innerRequest } from "../../utils/request";
 
 export type TextToVideoArgs = BaseArgs & TextToVideoInput;
 
 export type TextToVideoOutput = Blob;
 
-interface ReplicateOutput {
-	output: string;
-}
-
-interface NovitaOutput {
-	video: {
-		video_url: string;
-	};
-}
-
-const SUPPORTED_PROVIDERS = ["fal-ai", "novita", "replicate"] as const satisfies readonly InferenceProvider[];
-
 export async function textToVideo(args: TextToVideoArgs, options?: Options): Promise<TextToVideoOutput> {
-	if (!args.provider || !typedInclude(SUPPORTED_PROVIDERS, args.provider)) {
-		throw new Error(
-			`textToVideo inference is only supported for the following providers: ${SUPPORTED_PROVIDERS.join(", ")}`
-		);
-	}
-
-	const payload =
-		args.provider === "fal-ai" || args.provider === "replicate" || args.provider === "novita"
-			? { ...omit(args, ["inputs", "parameters"]), ...args.parameters, prompt: args.inputs }
-			: args;
-	const res = await request<FalAiQueueOutput | ReplicateOutput | NovitaOutput>(payload, {
+	const provider = args.provider ?? "hf-inference";
+	const providerHelper = getProviderHelper(provider, "text-to-video");
+	const { data: response } = await innerRequest<FalAiQueueOutput | ReplicateOutput | NovitaOutput>(args, {
 		...options,
 		task: "text-to-video",
 	});
-	if (args.provider === "fal-ai") {
-		const { url, info } = await makeRequestOptions(args, { ...options, task: "text-to-video" });
-		return await pollFalResponse(res as FalAiQueueOutput, url, info.headers as Record<string, string>);
-	} else if (args.provider === "novita") {
-		const isValidOutput =
-			typeof res === "object" &&
-			!!res &&
-			"video" in res &&
-			typeof res.video === "object" &&
-			!!res.video &&
-			"video_url" in res.video &&
-			typeof res.video.video_url === "string" &&
-			isUrl(res.video.video_url);
-		if (!isValidOutput) {
-			throw new InferenceOutputError("Expected { video: { video_url: string } }");
-		}
-		const urlResponse = await fetch((res as NovitaOutput).video.video_url);
-		return await urlResponse.blob();
-	} else {
-		/// TODO: Replicate: handle the case where the generation request "times out" / is async (ie output is null)
-		/// https://replicate.com/docs/topics/predictions/create-a-prediction
-		const isValidOutput =
-			typeof res === "object" && !!res && "output" in res && typeof res.output === "string" && isUrl(res.output);
-		if (!isValidOutput) {
-			throw new InferenceOutputError("Expected { output: string }");
-		}
-		const urlResponse = await fetch(res.output);
-		return await urlResponse.blob();
-	}
+	const { url, info } = await makeRequestOptions(args, { ...options, task: "text-to-video" });
+	return providerHelper.getResponse(response, url, info.headers as Record<string, string>);
 }

package/src/tasks/cv/zeroShotImageClassification.ts

@@ -1,9 +1,8 @@
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
-import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
-import type { RequestArgs } from "../../types";
-import { base64FromBytes } from "../../utils/base64FromBytes";
 import type { ZeroShotImageClassificationInput, ZeroShotImageClassificationOutput } from "@huggingface/tasks";
+import { getProviderHelper } from "../../lib/getProviderHelper";
+import type { BaseArgs, Options, RequestArgs } from "../../types";
+import { base64FromBytes } from "../../utils/base64FromBytes";
+import { innerRequest } from "../../utils/request";
 
 /**
  * @deprecated
@@ -45,15 +44,11 @@ export async function zeroShotImageClassification(
 	args: ZeroShotImageClassificationArgs,
 	options?: Options
 ): Promise<ZeroShotImageClassificationOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "zero-shot-image-classification");
 	const payload = await preparePayload(args);
-	const res = await request<ZeroShotImageClassificationOutput>(payload, {
+	const { data: res } = await innerRequest<ZeroShotImageClassificationOutput>(payload, {
 		...options,
 		task: "zero-shot-image-classification",
 	});
-	const isValidOutput =
-		Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
-	}
-	return res;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/index.ts

@@ -4,21 +4,23 @@ export * from "./custom/streamingRequest";
 
 // Audio tasks
 export * from "./audio/audioClassification";
+export * from "./audio/audioToAudio";
 export * from "./audio/automaticSpeechRecognition";
 export * from "./audio/textToSpeech";
-export * from "./audio/audioToAudio";
 
 // Computer Vision tasks
 export * from "./cv/imageClassification";
 export * from "./cv/imageSegmentation";
+export * from "./cv/imageToImage";
 export * from "./cv/imageToText";
 export * from "./cv/objectDetection";
 export * from "./cv/textToImage";
-export * from "./cv/imageToImage";
-export * from "./cv/zeroShotImageClassification";
 export * from "./cv/textToVideo";
+export * from "./cv/zeroShotImageClassification";
 
 // Natural Language Processing tasks
+export * from "./nlp/chatCompletion";
+export * from "./nlp/chatCompletionStream";
 export * from "./nlp/featureExtraction";
 export * from "./nlp/fillMask";
 export * from "./nlp/questionAnswering";
@@ -31,13 +33,11 @@ export * from "./nlp/textGenerationStream";
 export * from "./nlp/tokenClassification";
 export * from "./nlp/translation";
 export * from "./nlp/zeroShotClassification";
-export * from "./nlp/chatCompletion";
-export * from "./nlp/chatCompletionStream";
 
 // Multimodal tasks
 export * from "./multimodal/documentQuestionAnswering";
 export * from "./multimodal/visualQuestionAnswering";
 
 // Tabular tasks
-export * from "./tabular/tabularRegression";
 export * from "./tabular/tabularClassification";
+export * from "./tabular/tabularRegression";

package/src/tasks/multimodal/documentQuestionAnswering.ts

@@ -1,14 +1,12 @@
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
-import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
-import type { RequestArgs } from "../../types";
-import { toArray } from "../../utils/toArray";
-import { base64FromBytes } from "../../utils/base64FromBytes";
 import type {
 	DocumentQuestionAnsweringInput,
 	DocumentQuestionAnsweringInputData,
 	DocumentQuestionAnsweringOutput,
 } from "@huggingface/tasks";
+import { getProviderHelper } from "../../lib/getProviderHelper";
+import type { BaseArgs, Options, RequestArgs } from "../../types";
+import { base64FromBytes } from "../../utils/base64FromBytes";
+import { innerRequest } from "../../utils/request";
 
 /// Override the type to properly set inputs.image as Blob
 export type DocumentQuestionAnsweringArgs = BaseArgs &
@@ -21,6 +19,7 @@ export async function documentQuestionAnswering(
 	args: DocumentQuestionAnsweringArgs,
 	options?: Options
 ): Promise<DocumentQuestionAnsweringOutput[number]> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "document-question-answering");
 	const reqArgs: RequestArgs = {
 		...args,
 		inputs: {
@@ -29,27 +28,12 @@ export async function documentQuestionAnswering(
 			image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer())),
 		},
 	} as RequestArgs;
-	const res = toArray(
-		await request<DocumentQuestionAnsweringOutput | DocumentQuestionAnsweringOutput[number]>(reqArgs, {
+	const { data: res } = await innerRequest<DocumentQuestionAnsweringOutput | DocumentQuestionAnsweringOutput[number]>(
+		reqArgs,
+		{
 			...options,
 			task: "document-question-answering",
-		})
+		}
 	);
-
-	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[0];
+	return providerHelper.getResponse(res);
 }

package/src/tasks/multimodal/visualQuestionAnswering.ts

@@ -3,10 +3,10 @@ import type {
 	VisualQuestionAnsweringInputData,
 	VisualQuestionAnsweringOutput,
 } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options, RequestArgs } from "../../types";
 import { base64FromBytes } from "../../utils/base64FromBytes";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 /// Override the type to properly set inputs.image as Blob
 export type VisualQuestionAnsweringArgs = BaseArgs &
@@ -19,6 +19,7 @@ export async function visualQuestionAnswering(
 	args: VisualQuestionAnsweringArgs,
 	options?: Options
 ): Promise<VisualQuestionAnsweringOutput[number]> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "visual-question-answering");
 	const reqArgs: RequestArgs = {
 		...args,
 		inputs: {
@@ -27,17 +28,10 @@ export async function visualQuestionAnswering(
 			image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer())),
 		},
 	} as RequestArgs;
-	const res = await request<VisualQuestionAnsweringOutput>(reqArgs, {
+
+	const { data: res } = await innerRequest<VisualQuestionAnsweringOutput>(reqArgs, {
 		...options,
 		task: "visual-question-answering",
 	});
-	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[0];
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/chatCompletion.ts

@@ -1,7 +1,7 @@
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
-import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
 import type { ChatCompletionInput, ChatCompletionOutput } from "@huggingface/tasks";
+import { getProviderHelper } from "../../lib/getProviderHelper";
+import type { BaseArgs, Options } from "../../types";
+import { innerRequest } from "../../utils/request";
 
 /**
  * Use the chat completion endpoint to generate a response to a prompt, using OpenAI message completion API no stream
@@ -10,26 +10,10 @@ export async function chatCompletion(
 	args: BaseArgs & ChatCompletionInput,
 	options?: Options
 ): Promise<ChatCompletionOutput> {
-	const res = await request<ChatCompletionOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "conversational");
+	const { data: response } = await innerRequest<ChatCompletionOutput>(args, {
 		...options,
-		task: "text-generation",
-		chatCompletion: true,
+		task: "conversational",
 	});
-
-	const isValidOutput =
-		typeof res === "object" &&
-		Array.isArray(res?.choices) &&
-		typeof res?.created === "number" &&
-		typeof res?.id === "string" &&
-		typeof res?.model === "string" &&
-		/// Together.ai and Nebius do not output a system_fingerprint
-		(res.system_fingerprint === undefined ||
-			res.system_fingerprint === null ||
-			typeof res.system_fingerprint === "string") &&
-		typeof res?.usage === "object";
-
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected ChatCompletionOutput");
-	}
-	return res;
+	return providerHelper.getResponse(response);
 }

package/src/tasks/nlp/chatCompletionStream.ts

@@ -1,6 +1,6 @@
-import type { BaseArgs, Options } from "../../types";
-import { streamingRequest } from "../custom/streamingRequest";
 import type { ChatCompletionInput, ChatCompletionStreamOutput } from "@huggingface/tasks";
+import type { BaseArgs, Options } from "../../types";
+import { innerStreamingRequest } from "../../utils/request";
 
 /**
  * Use to continue text from a prompt. Same as `textGeneration` but returns generator that can be read one token at a time
@@ -9,9 +9,8 @@ export async function* chatCompletionStream(
 	args: BaseArgs & ChatCompletionInput,
 	options?: Options
 ): AsyncGenerator<ChatCompletionStreamOutput> {
-	yield* streamingRequest<ChatCompletionStreamOutput>(args, {
+	yield* innerStreamingRequest<ChatCompletionStreamOutput>(args, {
 		...options,
-		task: "text-generation",
-		chatCompletion: true,
+		task: "conversational",
 	});
 }

package/src/tasks/nlp/featureExtraction.ts

@@ -1,7 +1,7 @@
 import type { FeatureExtractionInput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type FeatureExtractionArgs = BaseArgs & FeatureExtractionInput;
 
@@ -17,25 +17,10 @@ export async function featureExtraction(
 	args: FeatureExtractionArgs,
 	options?: Options
 ): Promise<FeatureExtractionOutput> {
-	const res = await request<FeatureExtractionOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "feature-extraction");
+	const { data: res } = await innerRequest<FeatureExtractionOutput>(args, {
 		...options,
 		task: "feature-extraction",
 	});
-	let isValidOutput = true;
-
-	const isNumArrayRec = (arr: unknown[], maxDepth: number, curDepth = 0): boolean => {
-		if (curDepth > maxDepth) return false;
-		if (arr.every((x) => Array.isArray(x))) {
-			return arr.every((x) => isNumArrayRec(x as unknown[], maxDepth, curDepth + 1));
-		} else {
-			return arr.every((x) => typeof x === "number");
-		}
-	};
-
-	isValidOutput = Array.isArray(res) && isNumArrayRec(res, 3, 0);
-
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected Array<number[][][] | number[][] | number[] | number>");
-	}
-	return res;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/fillMask.ts

@@ -1,7 +1,7 @@
 import type { FillMaskInput, FillMaskOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type FillMaskArgs = BaseArgs & FillMaskInput;
 
@@ -9,23 +9,10 @@ export type FillMaskArgs = BaseArgs & FillMaskInput;
  * Tries to fill in a hole with a missing word (token to be precise). That’s the base task for BERT models.
  */
 export async function fillMask(args: FillMaskArgs, options?: Options): Promise<FillMaskOutput> {
-	const res = await request<FillMaskOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "fill-mask");
+	const { data: res } = await innerRequest<FillMaskOutput>(args, {
 		...options,
 		task: "fill-mask",
 	});
-	const isValidOutput =
-		Array.isArray(res) &&
-		res.every(
-			(x) =>
-				typeof x.score === "number" &&
-				typeof x.sequence === "string" &&
-				typeof x.token === "number" &&
-				typeof x.token_str === "string"
-		);
-	if (!isValidOutput) {
-		throw new InferenceOutputError(
-			"Expected Array<{score: number, sequence: string, token: number, token_str: string}>"
-		);
-	}
-	return res;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/questionAnswering.ts

@@ -1,7 +1,7 @@
 import type { QuestionAnsweringInput, QuestionAnsweringOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type QuestionAnsweringArgs = BaseArgs & QuestionAnsweringInput;
 
@@ -12,28 +12,10 @@ export async function questionAnswering(
 	args: QuestionAnsweringArgs,
 	options?: Options
 ): Promise<QuestionAnsweringOutput[number]> {
-	const res = await request<QuestionAnsweringOutput | QuestionAnsweringOutput[number]>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "question-answering");
+	const { data: res } = await innerRequest<QuestionAnsweringOutput | QuestionAnsweringOutput[number]>(args, {
 		...options,
 		task: "question-answering",
 	});
-	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 Array<{answer: string, end: number, score: number, start: number}>");
-	}
-	return Array.isArray(res) ? res[0] : res;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/sentenceSimilarity.ts

@@ -1,8 +1,7 @@
 import type { SentenceSimilarityInput, SentenceSimilarityOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
-import { omit } from "../../utils/omit";
+import { innerRequest } from "../../utils/request";
 
 export type SentenceSimilarityArgs = BaseArgs & SentenceSimilarityInput;
 
@@ -13,22 +12,10 @@ export async function sentenceSimilarity(
 	args: SentenceSimilarityArgs,
 	options?: Options
 ): Promise<SentenceSimilarityOutput> {
-	const res = await request<SentenceSimilarityOutput>(prepareInput(args), {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "sentence-similarity");
+	const { data: res } = await innerRequest<SentenceSimilarityOutput>(args, {
 		...options,
 		task: "sentence-similarity",
 	});
-
-	const isValidOutput = Array.isArray(res) && res.every((x) => typeof x === "number");
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected number[]");
-	}
-	return res;
-}
-
-function prepareInput(args: SentenceSimilarityArgs) {
-	return {
-		...omit(args, ["inputs", "parameters"]),
-		inputs: { ...omit(args.inputs, "sourceSentence") },
-		parameters: { source_sentence: args.inputs.sourceSentence, ...args.parameters },
-	};
+	return providerHelper.getResponse(res);
 }