@huggingface/inference 3.6.1 → 3.7.0

package/src/tasks/cv/imageToText.ts

@@ -1,7 +1,7 @@
 import type { ImageToTextInput, ImageToTextOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 import type { LegacyImageInput } from "./utils";
 import { preparePayload } from "./utils";
 
@@ -11,16 +11,14 @@ export type ImageToTextArgs = BaseArgs & (ImageToTextInput | LegacyImageInput);
  */
 export async function imageToText(args: ImageToTextArgs, options?: Options): Promise<ImageToTextOutput> {
 	const payload = preparePayload(args);
-	const res = (
-		await request<[ImageToTextOutput]>(payload, {
-			...options,
-			task: "image-to-text",
-		})
-	)?.[0];
+	const { data: res } = await innerRequest<[ImageToTextOutput]>(payload, {
+		...options,
+		task: "image-to-text",
+	});
 
-	if (typeof res?.generated_text !== "string") {
+	if (typeof res?.[0]?.generated_text !== "string") {
 		throw new InferenceOutputError("Expected {generated_text: string}");
 	}
 
-	return res;
+	return res?.[0];
 }

package/src/tasks/cv/objectDetection.ts

@@ -1,7 +1,7 @@
-import { request } from "../custom/request";
-import type { BaseArgs, Options } from "../../types";
-import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { ObjectDetectionInput, ObjectDetectionOutput } from "@huggingface/tasks";
+import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import type { BaseArgs, Options } from "../../types";
+import { innerRequest } from "../../utils/request";
 import { preparePayload, type LegacyImageInput } from "./utils";
 
 export type ObjectDetectionArgs = BaseArgs & (ObjectDetectionInput | LegacyImageInput);
@@ -12,7 +12,7 @@ export type ObjectDetectionArgs = BaseArgs & (ObjectDetectionInput | LegacyImage
  */
 export async function objectDetection(args: ObjectDetectionArgs, options?: Options): Promise<ObjectDetectionOutput> {
 	const payload = preparePayload(args);
-	const res = await request<ObjectDetectionOutput>(payload, {
+	const { data: res } = await innerRequest<ObjectDetectionOutput>(payload, {
 		...options,
 		task: "object-detection",
 	});

package/src/tasks/cv/textToImage.ts

@@ -1,9 +1,9 @@
 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 { omit } from "../../utils/omit";
+import { innerRequest } from "../../utils/request";
 
 export type TextToImageArgs = BaseArgs & TextToImageInput;
 
@@ -65,7 +65,7 @@ export async function textToImage(args: TextToImageArgs, options?: TextToImageOp
 					...getResponseFormatArg(args.provider),
 					prompt: args.inputs,
 			  };
-	const res = await request<
+	const { data: res } = await innerRequest<
 		| TextToImageOutput
 		| Base64ImageGeneration
 		| OutputUrlImageGeneration

package/src/tasks/cv/textToVideo.ts

@@ -1,21 +1,16 @@
-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 { isUrl } from "../../lib/isUrl";
+import { pollFalResponse, type FalAiQueueOutput } from "../../providers/fal-ai";
+import type { BaseArgs, InferenceProvider, Options } from "../../types";
+import { omit } from "../../utils/omit";
+import { innerRequest } from "../../utils/request";
 import { typedInclude } from "../../utils/typedInclude";
 
 export type TextToVideoArgs = BaseArgs & TextToVideoInput;
 
 export type TextToVideoOutput = Blob;
 
-interface FalAiOutput {
-	video: {
-		url: string;
-	};
-}
-
 interface ReplicateOutput {
 	output: string;
 }
@@ -39,49 +34,41 @@ export async function textToVideo(args: TextToVideoArgs, options?: Options): Pro
 		args.provider === "fal-ai" || args.provider === "replicate" || args.provider === "novita"
 			? { ...omit(args, ["inputs", "parameters"]), ...args.parameters, prompt: args.inputs }
 			: args;
-	const res = await request<FalAiOutput | ReplicateOutput | NovitaOutput>(payload, {
+	const { data, requestContext } = await innerRequest<FalAiQueueOutput | ReplicateOutput | NovitaOutput>(payload, {
 		...options,
 		task: "text-to-video",
 	});
+
 	if (args.provider === "fal-ai") {
-		const isValidOutput =
-			typeof res === "object" &&
-			!!res &&
-			"video" in res &&
-			typeof res.video === "object" &&
-			!!res.video &&
-			"url" in res.video &&
-			typeof res.video.url === "string" &&
-			isUrl(res.video.url);
-		if (!isValidOutput) {
-			throw new InferenceOutputError("Expected { video: { url: string } }");
-		}
-		const urlResponse = await fetch((res as FalAiOutput).video.url);
-		return await urlResponse.blob();
+		return await pollFalResponse(
+			data as FalAiQueueOutput,
+			requestContext.url,
+			requestContext.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);
+			typeof data === "object" &&
+			!!data &&
+			"video" in data &&
+			typeof data.video === "object" &&
+			!!data.video &&
+			"video_url" in data.video &&
+			typeof data.video.video_url === "string" &&
+			isUrl(data.video.video_url);
 		if (!isValidOutput) {
 			throw new InferenceOutputError("Expected { video: { video_url: string } }");
 		}
-		const urlResponse = await fetch((res as NovitaOutput).video.video_url);
+		const urlResponse = await fetch((data 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);
+			typeof data === "object" && !!data && "output" in data && typeof data.output === "string" && isUrl(data.output);
 		if (!isValidOutput) {
 			throw new InferenceOutputError("Expected { output: string }");
 		}
-		const urlResponse = await fetch(res.output);
+		const urlResponse = await fetch(data.output);
 		return await urlResponse.blob();
 	}
 }

package/src/tasks/cv/zeroShotImageClassification.ts

@@ -1,9 +1,8 @@
+import type { ZeroShotImageClassificationInput, ZeroShotImageClassificationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
-import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
-import type { RequestArgs } from "../../types";
+import type { BaseArgs, Options, RequestArgs } from "../../types";
 import { base64FromBytes } from "../../utils/base64FromBytes";
-import type { ZeroShotImageClassificationInput, ZeroShotImageClassificationOutput } from "@huggingface/tasks";
+import { innerRequest } from "../../utils/request";
 
 /**
  * @deprecated
@@ -46,7 +45,7 @@ export async function zeroShotImageClassification(
 	options?: Options
 ): Promise<ZeroShotImageClassificationOutput> {
 	const payload = await preparePayload(args);
-	const res = await request<ZeroShotImageClassificationOutput>(payload, {
+	const { data: res } = await innerRequest<ZeroShotImageClassificationOutput>(payload, {
 		...options,
 		task: "zero-shot-image-classification",
 	});

package/src/tasks/multimodal/documentQuestionAnswering.ts

@@ -1,14 +1,13 @@
-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 { InferenceOutputError } from "../../lib/InferenceOutputError";
+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 &
@@ -29,16 +28,17 @@ 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 output = toArray(res);
 	const isValidOutput =
-		Array.isArray(res) &&
-		res.every(
+		Array.isArray(output) &&
+		output.every(
 			(elem) =>
 				typeof elem === "object" &&
 				!!elem &&
@@ -51,5 +51,5 @@ export async function documentQuestionAnswering(
 		throw new InferenceOutputError("Expected Array<{answer: string, end?: number, score?: number, start?: number}>");
 	}
 
-	return res[0];
+	return output[0];
 }

package/src/tasks/multimodal/visualQuestionAnswering.ts

@@ -6,7 +6,7 @@ import type {
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 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 &
@@ -27,10 +27,12 @@ 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(

package/src/tasks/nlp/chatCompletion.ts

@@ -1,7 +1,7 @@
+import type { ChatCompletionInput, ChatCompletionOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
-import type { ChatCompletionInput, ChatCompletionOutput } from "@huggingface/tasks";
+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,12 +10,11 @@ export async function chatCompletion(
 	args: BaseArgs & ChatCompletionInput,
 	options?: Options
 ): Promise<ChatCompletionOutput> {
-	const res = await request<ChatCompletionOutput>(args, {
+	const { data: res } = await innerRequest<ChatCompletionOutput>(args, {
 		...options,
 		task: "text-generation",
 		chatCompletion: true,
 	});
-
 	const isValidOutput =
 		typeof res === "object" &&
 		Array.isArray(res?.choices) &&

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,7 +9,7 @@ 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,

package/src/tasks/nlp/featureExtraction.ts

@@ -1,7 +1,7 @@
 import type { FeatureExtractionInput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type FeatureExtractionArgs = BaseArgs & FeatureExtractionInput;
 
@@ -17,7 +17,7 @@ export async function featureExtraction(
 	args: FeatureExtractionArgs,
 	options?: Options
 ): Promise<FeatureExtractionOutput> {
-	const res = await request<FeatureExtractionOutput>(args, {
+	const { data: res } = await innerRequest<FeatureExtractionOutput>(args, {
 		...options,
 		task: "feature-extraction",
 	});

package/src/tasks/nlp/fillMask.ts

@@ -1,7 +1,7 @@
 import type { FillMaskInput, FillMaskOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type FillMaskArgs = BaseArgs & FillMaskInput;
 
@@ -9,7 +9,7 @@ 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 { data: res } = await innerRequest<FillMaskOutput>(args, {
 		...options,
 		task: "fill-mask",
 	});

package/src/tasks/nlp/questionAnswering.ts

@@ -1,7 +1,7 @@
 import type { QuestionAnsweringInput, QuestionAnsweringOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type QuestionAnsweringArgs = BaseArgs & QuestionAnsweringInput;
 
@@ -12,10 +12,11 @@ export async function questionAnswering(
 	args: QuestionAnsweringArgs,
 	options?: Options
 ): Promise<QuestionAnsweringOutput[number]> {
-	const res = await request<QuestionAnsweringOutput | QuestionAnsweringOutput[number]>(args, {
+	const { data: res } = await innerRequest<QuestionAnsweringOutput | QuestionAnsweringOutput[number]>(args, {
 		...options,
 		task: "question-answering",
 	});
+
 	const isValidOutput = Array.isArray(res)
 		? res.every(
 				(elem) =>

package/src/tasks/nlp/sentenceSimilarity.ts

@@ -1,8 +1,7 @@
 import type { SentenceSimilarityInput, SentenceSimilarityOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 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,7 +12,7 @@ export async function sentenceSimilarity(
 	args: SentenceSimilarityArgs,
 	options?: Options
 ): Promise<SentenceSimilarityOutput> {
-	const res = await request<SentenceSimilarityOutput>(prepareInput(args), {
+	const { data: res } = await innerRequest<SentenceSimilarityOutput>(args, {
 		...options,
 		task: "sentence-similarity",
 	});
@@ -24,11 +23,3 @@ export async function sentenceSimilarity(
 	}
 	return res;
 }
-
-function prepareInput(args: SentenceSimilarityArgs) {
-	return {
-		...omit(args, ["inputs", "parameters"]),
-		inputs: { ...omit(args.inputs, "sourceSentence") },
-		parameters: { source_sentence: args.inputs.sourceSentence, ...args.parameters },
-	};
-}

package/src/tasks/nlp/summarization.ts

@@ -1,7 +1,7 @@
 import type { SummarizationInput, SummarizationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type SummarizationArgs = BaseArgs & SummarizationInput;
 
@@ -9,7 +9,7 @@ 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 res = await request<SummarizationOutput[]>(args, {
+	const { data: res } = await innerRequest<SummarizationOutput[]>(args, {
 		...options,
 		task: "summarization",
 	});

package/src/tasks/nlp/tableQuestionAnswering.ts

@@ -1,7 +1,7 @@
 import type { TableQuestionAnsweringInput, TableQuestionAnsweringOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type TableQuestionAnsweringArgs = BaseArgs & TableQuestionAnsweringInput;
 
@@ -12,7 +12,7 @@ export async function tableQuestionAnswering(
 	args: TableQuestionAnsweringArgs,
 	options?: Options
 ): Promise<TableQuestionAnsweringOutput[number]> {
-	const res = await request<TableQuestionAnsweringOutput | TableQuestionAnsweringOutput[number]>(args, {
+	const { data: res } = await innerRequest<TableQuestionAnsweringOutput | TableQuestionAnsweringOutput[number]>(args, {
 		...options,
 		task: "table-question-answering",
 	});

package/src/tasks/nlp/textClassification.ts

@@ -1,7 +1,7 @@
 import type { TextClassificationInput, TextClassificationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 export type TextClassificationArgs = BaseArgs & TextClassificationInput;
 
@@ -12,16 +12,15 @@ export async function textClassification(
 	args: TextClassificationArgs,
 	options?: Options
 ): Promise<TextClassificationOutput> {
-	const res = (
-		await request<TextClassificationOutput>(args, {
-			...options,
-			task: "text-classification",
-		})
-	)?.[0];
+	const { data: res } = await innerRequest<TextClassificationOutput>(args, {
+		...options,
+		task: "text-classification",
+	});
+	const output = res?.[0];
 	const isValidOutput =
-		Array.isArray(res) && res.every((x) => typeof x?.label === "string" && typeof x.score === "number");
+		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 res;
+	return output;
 }

package/src/tasks/nlp/textGeneration.ts

@@ -6,9 +6,9 @@ import type {
 } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { toArray } from "../../utils/toArray";
-import { request } from "../custom/request";
 import { omit } from "../../utils/omit";
+import { innerRequest } from "../../utils/request";
+import { toArray } from "../../utils/toArray";
 
 export type { TextGenerationInput, TextGenerationOutput };
 
@@ -37,7 +37,7 @@ export async function textGeneration(
 ): Promise<TextGenerationOutput> {
 	if (args.provider === "together") {
 		args.prompt = args.inputs;
-		const raw = await request<TogeteherTextCompletionOutput>(args, {
+		const { data: raw } = await innerRequest<TogeteherTextCompletionOutput>(args, {
 			...options,
 			task: "text-generation",
 		});
@@ -61,10 +61,12 @@ export async function textGeneration(
 				: undefined),
 			...omit(args, ["inputs", "parameters"]),
 		};
-		const raw = await request<HyperbolicTextCompletionOutput>(payload, {
-			...options,
-			task: "text-generation",
-		});
+		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) {
@@ -75,18 +77,16 @@ export async function textGeneration(
 			generated_text: completion.message.content,
 		};
 	} else {
-		const res = toArray(
-			await request<TextGenerationOutput | TextGenerationOutput[]>(args, {
-				...options,
-				task: "text-generation",
-			})
-		);
-
+		const { data: res } = await innerRequest<TextGenerationOutput | TextGenerationOutput[]>(args, {
+			...options,
+			task: "text-generation",
+		});
+		const output = toArray(res);
 		const isValidOutput =
-			Array.isArray(res) && res.every((x) => "generated_text" in x && typeof x?.generated_text === "string");
+			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 (res as TextGenerationOutput[])?.[0];
+		return (output as TextGenerationOutput[])?.[0];
 	}
 }

package/src/tasks/nlp/textGenerationStream.ts

@@ -1,6 +1,6 @@
 import type { TextGenerationInput } from "@huggingface/tasks";
 import type { BaseArgs, Options } from "../../types";
-import { streamingRequest } from "../custom/streamingRequest";
+import { innerStreamingRequest } from "../../utils/request";
 
 export interface TextGenerationStreamToken {
 	/** Token ID from the model tokenizer */
@@ -89,7 +89,7 @@ export async function* textGenerationStream(
 	args: BaseArgs & TextGenerationInput,
 	options?: Options
 ): AsyncGenerator<TextGenerationStreamOutput> {
-	yield* streamingRequest<TextGenerationStreamOutput>(args, {
+	yield* innerStreamingRequest<TextGenerationStreamOutput>(args, {
 		...options,
 		task: "text-generation",
 	});

package/src/tasks/nlp/tokenClassification.ts

@@ -1,8 +1,8 @@
 import type { TokenClassificationInput, TokenClassificationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
+import { innerRequest } from "../../utils/request";
 import { toArray } from "../../utils/toArray";
-import { request } from "../custom/request";
 
 export type TokenClassificationArgs = BaseArgs & TokenClassificationInput;
 
@@ -13,15 +13,14 @@ export async function tokenClassification(
 	args: TokenClassificationArgs,
 	options?: Options
 ): Promise<TokenClassificationOutput> {
-	const res = toArray(
-		await request<TokenClassificationOutput[number] | TokenClassificationOutput>(args, {
-			...options,
-			task: "token-classification",
-		})
-	);
+	const { data: res } = await innerRequest<TokenClassificationOutput[number] | TokenClassificationOutput>(args, {
+		...options,
+		task: "token-classification",
+	});
+	const output = toArray(res);
 	const isValidOutput =
-		Array.isArray(res) &&
-		res.every(
+		Array.isArray(output) &&
+		output.every(
 			(x) =>
 				typeof x.end === "number" &&
 				typeof x.entity_group === "string" &&
@@ -34,5 +33,5 @@ export async function tokenClassification(
 			"Expected Array<{end: number, entity_group: string, score: number, start: number, word: string}>"
 		);
 	}
-	return res;
+	return output;
 }

package/src/tasks/nlp/translation.ts

@@ -1,14 +1,14 @@
 import type { TranslationInput, TranslationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
-import { request } from "../custom/request";
+import { innerRequest } from "../../utils/request";
 
 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 res = await request<TranslationOutput>(args, {
+	const { data: res } = await innerRequest<TranslationOutput>(args, {
 		...options,
 		task: "translation",
 	});

package/src/tasks/nlp/zeroShotClassification.ts

@@ -1,8 +1,8 @@
 import type { ZeroShotClassificationInput, ZeroShotClassificationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
+import { innerRequest } from "../../utils/request";
 import { toArray } from "../../utils/toArray";
-import { request } from "../custom/request";
 
 export type ZeroShotClassificationArgs = BaseArgs & ZeroShotClassificationInput;
 
@@ -13,15 +13,14 @@ export async function zeroShotClassification(
 	args: ZeroShotClassificationArgs,
 	options?: Options
 ): Promise<ZeroShotClassificationOutput> {
-	const res = toArray(
-		await request<ZeroShotClassificationOutput[number] | ZeroShotClassificationOutput>(args, {
-			...options,
-			task: "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(res) &&
-		res.every(
+		Array.isArray(output) &&
+		output.every(
 			(x) =>
 				Array.isArray(x.labels) &&
 				x.labels.every((_label) => typeof _label === "string") &&
@@ -32,5 +31,5 @@ export async function zeroShotClassification(
 	if (!isValidOutput) {
 		throw new InferenceOutputError("Expected Array<{labels: string[], scores: number[], sequence: string}>");
 	}
-	return res;
+	return output;
 }