@huggingface/inference 3.7.0 → 3.8.0

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,14 @@ export async function tableQuestionAnswering(
 	args: TableQuestionAnsweringArgs,
 	options?: Options
 ): Promise<TableQuestionAnsweringOutput[number]> {
-	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")
-		)
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "table-question-answering");
+	const { data: res } = await innerRequest<TableQuestionAnsweringOutput | TableQuestionAnsweringOutput[number]>(
+		args,
+		providerHelper,
+		{
+			...options,
+			task: "table-question-answering",
+		}
 	);
+	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 { data: res } = await innerRequest<TextClassificationOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-classification");
+	const { data: res } = await innerRequest<TextClassificationOutput>(args, providerHelper, {
 		...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,12 @@ 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 providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-generation");
+	const { data: response } = await innerRequest<
+		HyperbolicTextCompletionOutput | TextGenerationOutput | TextGenerationOutput[]
+	>(args, providerHelper, {
+		...options,
+		task: "text-generation",
+	});
+	return providerHelper.getResponse(response);
 }

package/src/tasks/nlp/textGenerationStream.ts

@@ -1,4 +1,5 @@
 import type { TextGenerationInput } from "@huggingface/tasks";
+import { getProviderHelper } from "../../lib/getProviderHelper";
 import type { BaseArgs, Options } from "../../types";
 import { innerStreamingRequest } from "../../utils/request";
 
@@ -89,7 +90,8 @@ export async function* textGenerationStream(
 	args: BaseArgs & TextGenerationInput,
 	options?: Options
 ): AsyncGenerator<TextGenerationStreamOutput> {
-	yield* innerStreamingRequest<TextGenerationStreamOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-generation");
+	yield* innerStreamingRequest<TextGenerationStreamOutput>(args, providerHelper, {
 		...options,
 		task: "text-generation",
 	});

package/src/tasks/nlp/tokenClassification.ts

@@ -1,8 +1,7 @@
 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";
 
 export type TokenClassificationArgs = BaseArgs & TokenClassificationInput;
 
@@ -13,25 +12,14 @@ export async function tokenClassification(
 	args: TokenClassificationArgs,
 	options?: Options
 ): Promise<TokenClassificationOutput> {
-	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;
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "token-classification");
+	const { data: res } = await innerRequest<TokenClassificationOutput[number] | TokenClassificationOutput>(
+		args,
+		providerHelper,
+		{
+			...options,
+			task: "token-classification",
+		}
+	);
+	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 { data: res } = await innerRequest<TranslationOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "translation");
+	const { data: res } = await innerRequest<TranslationOutput>(args, providerHelper, {
 		...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,8 +1,7 @@
 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";
 
 export type ZeroShotClassificationArgs = BaseArgs & ZeroShotClassificationInput;
 
@@ -13,23 +12,14 @@ export async function zeroShotClassification(
 	args: ZeroShotClassificationArgs,
 	options?: Options
 ): Promise<ZeroShotClassificationOutput> {
-	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;
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "zero-shot-classification");
+	const { data: res } = await innerRequest<ZeroShotClassificationOutput[number] | ZeroShotClassificationOutput>(
+		args,
+		providerHelper,
+		{
+			...options,
+			task: "zero-shot-classification",
+		}
+	);
+	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 { data: res } = await innerRequest<TabularClassificationOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-classification");
+	const { data: res } = await innerRequest<TabularClassificationOutput>(args, providerHelper, {
 		...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 { data: res } = await innerRequest<TabularRegressionOutput>(args, {
+	const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-regression");
+	const { data: res } = await innerRequest<TabularRegressionOutput>(args, providerHelper, {
 		...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);
 }

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { ChatCompletionInput, PipelineType } from "@huggingface/tasks";
+import type { InferenceProviderModelMapping } from "./lib/getInferenceProviderMapping";
 
 /**
  * HF model id, like "meta-llama/Llama-3.3-70B-Instruct"
@@ -34,7 +35,7 @@ export interface Options {
 	billTo?: string;
 }
 
-export type InferenceTask = Exclude<PipelineType, "other">;
+export type InferenceTask = Exclude<PipelineType, "other"> | "conversational";
 
 export const INFERENCE_PROVIDERS = [
 	"black-forest-labs",
@@ -101,14 +102,6 @@ export type RequestArgs = BaseArgs &
 		parameters?: Record<string, unknown>;
 	};
 
-export interface ProviderConfig {
-	makeBaseUrl: ((task?: InferenceTask) => string) | (() => string);
-	makeBody: (params: BodyParams) => Record<string, unknown>;
-	makeHeaders: (params: HeaderParams) => Record<string, string>;
-	makeUrl: (params: UrlParams) => string;
-	clientSideRoutingOnly?: boolean;
-}
-
 export type AuthMethod = "none" | "hf-token" | "credentials-include" | "provider-key";
 
 export interface HeaderParams {
@@ -118,15 +111,13 @@ export interface HeaderParams {
 
 export interface UrlParams {
 	authMethod: AuthMethod;
-	baseUrl: string;
 	model: string;
 	task?: InferenceTask;
-	chatCompletion?: boolean;
 }
 
-export interface BodyParams {
-	args: Record<string, unknown>;
-	chatCompletion?: boolean;
+export interface BodyParams<T extends Record<string, unknown> = Record<string, unknown>> {
+	args: T;
 	model: string;
+	mapping?: InferenceProviderModelMapping | undefined;
 	task?: InferenceTask;
 }

package/src/utils/request.ts

@@ -1,3 +1,4 @@
+import type { getProviderHelper } from "../lib/getProviderHelper";
 import { makeRequestOptions } from "../lib/makeRequestOptions";
 import type { InferenceTask, Options, RequestArgs } from "../types";
 import type { EventSourceMessage } from "../vendor/fetch-event-source/parse";
@@ -16,6 +17,7 @@ export interface ResponseWrapper<T> {
  */
 export async function innerRequest<T>(
 	args: RequestArgs,
+	providerHelper: ReturnType<typeof getProviderHelper>,
 	options?: Options & {
 		/** In most cases (unless we pass a endpointUrl) we know the task */
 		task?: InferenceTask;
@@ -23,13 +25,13 @@ export async function innerRequest<T>(
 		chatCompletion?: boolean;
 	}
 ): Promise<ResponseWrapper<T>> {
-	const { url, info } = await makeRequestOptions(args, options);
+	const { url, info } = await makeRequestOptions(args, providerHelper, options);
 	const response = await (options?.fetch ?? fetch)(url, info);
 
 	const requestContext: ResponseWrapper<T>["requestContext"] = { url, info };
 
 	if (options?.retry_on_error !== false && response.status === 503) {
-		return innerRequest(args, options);
+		return innerRequest(args, providerHelper, options);
 	}
 
 	if (!response.ok) {
@@ -65,6 +67,7 @@ export async function innerRequest<T>(
  */
 export async function* innerStreamingRequest<T>(
 	args: RequestArgs,
+	providerHelper: ReturnType<typeof getProviderHelper>,
 	options?: Options & {
 		/** In most cases (unless we pass a endpointUrl) we know the task */
 		task?: InferenceTask;
@@ -72,11 +75,11 @@ export async function* innerStreamingRequest<T>(
 		chatCompletion?: boolean;
 	}
 ): AsyncGenerator<T> {
-	const { url, info } = await makeRequestOptions({ ...args, stream: true }, options);
+	const { url, info } = await makeRequestOptions({ ...args, stream: true }, providerHelper, options);
 	const response = await (options?.fetch ?? fetch)(url, info);
 
 	if (options?.retry_on_error !== false && response.status === 503) {
-		return yield* innerStreamingRequest(args, options);
+		return yield* innerStreamingRequest(args, providerHelper, options);
 	}
 	if (!response.ok) {
 		if (response.headers.get("Content-Type")?.startsWith("application/json")) {

package/dist/src/lib/getProviderModelId.d.ts

@@ -1,10 +0,0 @@
-import type { InferenceProvider, InferenceTask, Options, RequestArgs } from "../types";
-export declare function getProviderModelId(params: {
-    model: string;
-    provider: InferenceProvider;
-}, args: RequestArgs, options?: {
-    task?: InferenceTask;
-    chatCompletion?: boolean;
-    fetch?: Options["fetch"];
-}): Promise<string>;
-//# sourceMappingURL=getProviderModelId.d.ts.map

package/dist/src/lib/getProviderModelId.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getProviderModelId.d.ts","sourceRoot":"","sources":["../../../src/lib/getProviderModelId.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAW,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAShG,wBAAsB,kBAAkB,CACvC,MAAM,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,iBAAiB,CAAC;CAC5B,EACD,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE;IACR,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CACpB,GACJ,OAAO,CAAC,MAAM,CAAC,CAoDjB"}

package/src/lib/getProviderModelId.ts

@@ -1,74 +0,0 @@
-import type { WidgetType } from "@huggingface/tasks";
-import type { InferenceProvider, InferenceTask, ModelId, Options, RequestArgs } from "../types";
-import { HF_HUB_URL } from "../config";
-import { HARDCODED_MODEL_ID_MAPPING } from "../providers/consts";
-
-type InferenceProviderMapping = Partial<
-	Record<InferenceProvider, { providerId: string; status: "live" | "staging"; task: WidgetType }>
->;
-const inferenceProviderMappingCache = new Map<ModelId, InferenceProviderMapping>();
-
-export async function getProviderModelId(
-	params: {
-		model: string;
-		provider: InferenceProvider;
-	},
-	args: RequestArgs,
-	options: {
-		task?: InferenceTask;
-		chatCompletion?: boolean;
-		fetch?: Options["fetch"];
-	} = {}
-): Promise<string> {
-	if (params.provider === "hf-inference") {
-		return params.model;
-	}
-	if (!options.task) {
-		throw new Error("task must be specified when using a third-party provider");
-	}
-	const task: WidgetType =
-		options.task === "text-generation" && options.chatCompletion ? "conversational" : options.task;
-
-	// A dict called HARDCODED_MODEL_ID_MAPPING takes precedence in all cases (useful for dev purposes)
-	if (HARDCODED_MODEL_ID_MAPPING[params.provider]?.[params.model]) {
-		return HARDCODED_MODEL_ID_MAPPING[params.provider][params.model];
-	}
-
-	let inferenceProviderMapping: InferenceProviderMapping | null;
-	if (inferenceProviderMappingCache.has(params.model)) {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		inferenceProviderMapping = inferenceProviderMappingCache.get(params.model)!;
-	} else {
-		inferenceProviderMapping = await (options?.fetch ?? fetch)(
-			`${HF_HUB_URL}/api/models/${params.model}?expand[]=inferenceProviderMapping`,
-			{
-				headers: args.accessToken?.startsWith("hf_") ? { Authorization: `Bearer ${args.accessToken}` } : {},
-			}
-		)
-			.then((resp) => resp.json())
-			.then((json) => json.inferenceProviderMapping)
-			.catch(() => null);
-	}
-
-	if (!inferenceProviderMapping) {
-		throw new Error(`We have not been able to find inference provider information for model ${params.model}.`);
-	}
-
-	const providerMapping = inferenceProviderMapping[params.provider];
-	if (providerMapping) {
-		if (providerMapping.task !== task) {
-			throw new Error(
-				`Model ${params.model} is not supported for task ${task} and provider ${params.provider}. Supported task: ${providerMapping.task}.`
-			);
-		}
-		if (providerMapping.status === "staging") {
-			console.warn(
-				`Model ${params.model} is in staging mode for provider ${params.provider}. Meant for test purposes only.`
-			);
-		}
-		// TODO: how is it handled server-side if model has multiple tasks (e.g. `text-generation` + `conversational`)?
-		return providerMapping.providerId;
-	}
-
-	throw new Error(`Model ${params.model} is not supported provider ${params.provider}.`);
-}