@huggingface/inference 3.7.0 → 3.7.1

package/src/tasks/cv/zeroShotImageClassification.ts

@@ -1,5 +1,5 @@
 import type { ZeroShotImageClassificationInput, ZeroShotImageClassificationOutput } 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 { innerRequest } from "../../utils/request";
@@ -44,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 { 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

@@ -3,11 +3,10 @@ import type {
 	DocumentQuestionAnsweringInputData,
 	DocumentQuestionAnsweringOutput,
 } 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 { innerRequest } from "../../utils/request";
-import { toArray } from "../../utils/toArray";
 
 /// Override the type to properly set inputs.image as Blob
 export type DocumentQuestionAnsweringArgs = BaseArgs &
@@ -20,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: {
@@ -35,21 +35,5 @@ export async function documentQuestionAnswering(
 			task: "document-question-answering",
 		}
 	);
-	const output = toArray(res);
-	const isValidOutput =
-		Array.isArray(output) &&
-		output.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 output[0];
+	return providerHelper.getResponse(res);
 }

package/src/tasks/multimodal/visualQuestionAnswering.ts

@@ -3,7 +3,7 @@ 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 { innerRequest } from "../../utils/request";
@@ -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: {
@@ -32,14 +33,5 @@ export async function visualQuestionAnswering(
 		...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,5 +1,5 @@
 import type { ChatCompletionInput, ChatCompletionOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -10,25 +10,10 @@ export async function chatCompletion(
 	args: BaseArgs & ChatCompletionInput,
 	options?: Options
 ): Promise<ChatCompletionOutput> {
-	const { data: res } = await innerRequest<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

@@ -11,7 +11,6 @@ export async function* chatCompletionStream(
 ): AsyncGenerator<ChatCompletionStreamOutput> {
 	yield* innerStreamingRequest<ChatCompletionStreamOutput>(args, {
 		...options,
-		task: "text-generation",
-		chatCompletion: true,
+		task: "conversational",
 	});
 }

package/src/tasks/nlp/featureExtraction.ts

@@ -1,5 +1,5 @@
 import type { FeatureExtractionInput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -17,25 +17,10 @@ export async function featureExtraction(
 	args: FeatureExtractionArgs,
 	options?: Options
 ): Promise<FeatureExtractionOutput> {
+	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,5 +1,5 @@
 import type { FillMaskInput, FillMaskOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -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 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,5 +1,5 @@
 import type { QuestionAnsweringInput, QuestionAnsweringOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -12,29 +12,10 @@ export async function questionAnswering(
 	args: QuestionAnsweringArgs,
 	options?: Options
 ): Promise<QuestionAnsweringOutput[number]> {
+	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,5 +1,5 @@
 import type { SentenceSimilarityInput, SentenceSimilarityOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -12,14 +12,10 @@ export async function sentenceSimilarity(
 	args: SentenceSimilarityArgs,
 	options?: Options
 ): Promise<SentenceSimilarityOutput> {
+	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;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/summarization.ts

@@ -1,5 +1,5 @@
 import type { SummarizationInput, SummarizationOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -9,13 +9,10 @@ export type SummarizationArgs = BaseArgs & SummarizationInput;
  * This task is well known to summarize longer text into shorter text. Be careful, some models have a maximum length of input. That means that the summary cannot handle full books for instance. Be careful when choosing your model.
  */
 export async function summarization(args: SummarizationArgs, options?: Options): Promise<SummarizationOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "summarization");
 	const { data: res } = await innerRequest<SummarizationOutput[]>(args, {
 		...options,
 		task: "summarization",
 	});
-	const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.summary_text === "string");
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected Array<{summary_text: string}>");
-	}
-	return res?.[0];
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/tableQuestionAnswering.ts

@@ -1,5 +1,5 @@
 import type { TableQuestionAnsweringInput, TableQuestionAnsweringOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -12,34 +12,10 @@ export async function tableQuestionAnswering(
 	args: TableQuestionAnsweringArgs,
 	options?: Options
 ): Promise<TableQuestionAnsweringOutput[number]> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "table-question-answering");
 	const { data: res } = await innerRequest<TableQuestionAnsweringOutput | TableQuestionAnsweringOutput[number]>(args, {
 		...options,
 		task: "table-question-answering",
 	});
-	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 Array.isArray(res) ? res[0] : res;
-}
-
-function validate(elem: unknown): elem is TableQuestionAnsweringOutput[number] {
-	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: unknown): x is string => typeof x === "string") &&
-		"coordinates" in elem &&
-		Array.isArray(elem.coordinates) &&
-		elem.coordinates.every(
-			(coord: unknown): coord is number[] => Array.isArray(coord) && coord.every((x) => typeof x === "number")
-		)
-	);
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/textClassification.ts

@@ -1,5 +1,5 @@
 import type { TextClassificationInput, TextClassificationOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -12,15 +12,10 @@ export async function textClassification(
 	args: TextClassificationArgs,
 	options?: Options
 ): Promise<TextClassificationOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-classification");
 	const { data: res } = await innerRequest<TextClassificationOutput>(args, {
 		...options,
 		task: "text-classification",
 	});
-	const output = res?.[0];
-	const isValidOutput =
-		Array.isArray(output) && output.every((x) => typeof x?.label === "string" && typeof x.score === "number");
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
-	}
-	return output;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/textGeneration.ts

@@ -1,33 +1,11 @@
-import type {
-	ChatCompletionOutput,
-	TextGenerationInput,
-	TextGenerationOutput,
-	TextGenerationOutputFinishReason,
-} from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import type { TextGenerationInput, TextGenerationOutput } from "@huggingface/tasks";
+import { getProviderHelper } from "../../lib/getProviderHelper";
+import type { HyperbolicTextCompletionOutput } from "../../providers/hyperbolic";
 import type { BaseArgs, Options } from "../../types";
-import { omit } from "../../utils/omit";
 import { innerRequest } from "../../utils/request";
-import { toArray } from "../../utils/toArray";
 
 export type { TextGenerationInput, TextGenerationOutput };
 
-interface TogeteherTextCompletionOutput extends Omit<ChatCompletionOutput, "choices"> {
-	choices: Array<{
-		text: string;
-		finish_reason: TextGenerationOutputFinishReason;
-		seed: number;
-		logprobs: unknown;
-		index: number;
-	}>;
-}
-
-interface HyperbolicTextCompletionOutput extends Omit<ChatCompletionOutput, "choices"> {
-	choices: Array<{
-		message: { content: string };
-	}>;
-}
-
 /**
  * Use to continue text from a prompt. This is a very generic task. Recommended model: gpt2 (it’s a simple model, but fun to play with).
  */
@@ -35,58 +13,13 @@ export async function textGeneration(
 	args: BaseArgs & TextGenerationInput,
 	options?: Options
 ): Promise<TextGenerationOutput> {
-	if (args.provider === "together") {
-		args.prompt = args.inputs;
-		const { data: raw } = await innerRequest<TogeteherTextCompletionOutput>(args, {
-			...options,
-			task: "text-generation",
-		});
-		const isValidOutput =
-			typeof raw === "object" && "choices" in raw && Array.isArray(raw?.choices) && typeof raw?.model === "string";
-		if (!isValidOutput) {
-			throw new InferenceOutputError("Expected ChatCompletionOutput");
-		}
-		const completion = raw.choices[0];
-		return {
-			generated_text: completion.text,
-		};
-	} else if (args.provider === "hyperbolic") {
-		const payload = {
-			messages: [{ content: args.inputs, role: "user" }],
-			...(args.parameters
-				? {
-						max_tokens: args.parameters.max_new_tokens,
-						...omit(args.parameters, "max_new_tokens"),
-				  }
-				: undefined),
-			...omit(args, ["inputs", "parameters"]),
-		};
-		const raw = (
-			await innerRequest<HyperbolicTextCompletionOutput>(payload, {
-				...options,
-				task: "text-generation",
-			})
-		).data;
-		const isValidOutput =
-			typeof raw === "object" && "choices" in raw && Array.isArray(raw?.choices) && typeof raw?.model === "string";
-		if (!isValidOutput) {
-			throw new InferenceOutputError("Expected ChatCompletionOutput");
-		}
-		const completion = raw.choices[0];
-		return {
-			generated_text: completion.message.content,
-		};
-	} else {
-		const { data: res } = await innerRequest<TextGenerationOutput | TextGenerationOutput[]>(args, {
-			...options,
-			task: "text-generation",
-		});
-		const output = toArray(res);
-		const isValidOutput =
-			Array.isArray(output) && output.every((x) => "generated_text" in x && typeof x?.generated_text === "string");
-		if (!isValidOutput) {
-			throw new InferenceOutputError("Expected Array<{generated_text: string}>");
-		}
-		return (output as TextGenerationOutput[])?.[0];
-	}
+	const provider = args.provider ?? "hf-inference";
+	const providerHelper = getProviderHelper(provider, "text-generation");
+	const { data: response } = await innerRequest<
+		HyperbolicTextCompletionOutput | TextGenerationOutput | TextGenerationOutput[]
+	>(args, {
+		...options,
+		task: "text-generation",
+	});
+	return providerHelper.getResponse(response);
 }

package/src/tasks/nlp/tokenClassification.ts

@@ -1,5 +1,5 @@
 import type { TokenClassificationInput, TokenClassificationOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 import { toArray } from "../../utils/toArray";
@@ -13,25 +13,10 @@ export async function tokenClassification(
 	args: TokenClassificationArgs,
 	options?: Options
 ): Promise<TokenClassificationOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "token-classification");
 	const { data: res } = await innerRequest<TokenClassificationOutput[number] | TokenClassificationOutput>(args, {
 		...options,
 		task: "token-classification",
 	});
-	const output = toArray(res);
-	const isValidOutput =
-		Array.isArray(output) &&
-		output.every(
-			(x) =>
-				typeof x.end === "number" &&
-				typeof x.entity_group === "string" &&
-				typeof x.score === "number" &&
-				typeof x.start === "number" &&
-				typeof x.word === "string"
-		);
-	if (!isValidOutput) {
-		throw new InferenceOutputError(
-			"Expected Array<{end: number, entity_group: string, score: number, start: number, word: string}>"
-		);
-	}
-	return output;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/translation.ts

@@ -1,5 +1,5 @@
 import type { TranslationInput, TranslationOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -8,13 +8,10 @@ export type TranslationArgs = BaseArgs & TranslationInput;
  * This task is well known to translate text from one language to another. Recommended model: Helsinki-NLP/opus-mt-ru-en.
  */
 export async function translation(args: TranslationArgs, options?: Options): Promise<TranslationOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "translation");
 	const { data: res } = await innerRequest<TranslationOutput>(args, {
 		...options,
 		task: "translation",
 	});
-	const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.translation_text === "string");
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected type Array<{translation_text: string}>");
-	}
-	return res?.length === 1 ? res?.[0] : res;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/nlp/zeroShotClassification.ts

@@ -1,5 +1,5 @@
 import type { ZeroShotClassificationInput, ZeroShotClassificationOutput } from "@huggingface/tasks";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 import { toArray } from "../../utils/toArray";
@@ -13,23 +13,10 @@ export async function zeroShotClassification(
 	args: ZeroShotClassificationArgs,
 	options?: Options
 ): Promise<ZeroShotClassificationOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "zero-shot-classification");
 	const { data: res } = await innerRequest<ZeroShotClassificationOutput[number] | ZeroShotClassificationOutput>(args, {
 		...options,
 		task: "zero-shot-classification",
 	});
-	const output = toArray(res);
-	const isValidOutput =
-		Array.isArray(output) &&
-		output.every(
-			(x) =>
-				Array.isArray(x.labels) &&
-				x.labels.every((_label) => typeof _label === "string") &&
-				Array.isArray(x.scores) &&
-				x.scores.every((_score) => typeof _score === "number") &&
-				typeof x.sequence === "string"
-		);
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected Array<{labels: string[], scores: number[], sequence: string}>");
-	}
-	return output;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/tabular/tabularClassification.ts

@@ -1,4 +1,4 @@
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -25,13 +25,10 @@ export async function tabularClassification(
 	args: TabularClassificationArgs,
 	options?: Options
 ): Promise<TabularClassificationOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-classification");
 	const { data: res } = await innerRequest<TabularClassificationOutput>(args, {
 		...options,
 		task: "tabular-classification",
 	});
-	const isValidOutput = Array.isArray(res) && res.every((x) => typeof x === "number");
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected number[]");
-	}
-	return res;
+	return providerHelper.getResponse(res);
 }

package/src/tasks/tabular/tabularRegression.ts

@@ -1,4 +1,4 @@
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerRequest } from "../../utils/request";
 
@@ -25,13 +25,10 @@ export async function tabularRegression(
 	args: TabularRegressionArgs,
 	options?: Options
 ): Promise<TabularRegressionOutput> {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-regression");
 	const { data: res } = await innerRequest<TabularRegressionOutput>(args, {
 		...options,
 		task: "tabular-regression",
 	});
-	const isValidOutput = Array.isArray(res) && res.every((x) => typeof x === "number");
-	if (!isValidOutput) {
-		throw new InferenceOutputError("Expected number[]");
-	}
-	return res;
+	return providerHelper.getResponse(res);
 }