@huggingface/inference 3.0.1 → 3.1.0

package/src/tasks/nlp/tableQuestionAnswering.ts

@@ -1,38 +1,9 @@
+import type { TableQuestionAnsweringInput, TableQuestionAnsweringOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
 import { request } from "../custom/request";
 
-export type TableQuestionAnsweringArgs = BaseArgs & {
-	inputs: {
-		/**
-		 * The query in plain text that you want to ask the table
-		 */
-		query: string;
-		/**
-		 * A table of data represented as a dict of list where entries are headers and the lists are all the values, all lists must have the same size.
-		 */
-		table: Record<string, string[]>;
-	};
-};
-
-export interface TableQuestionAnsweringOutput {
-	/**
-	 * The aggregator used to get the answer
-	 */
-	aggregator: string;
-	/**
-	 * The plaintext answer
-	 */
-	answer: string;
-	/**
-	 * A list of coordinates of the cells contents
-	 */
-	cells: string[];
-	/**
-	 * a list of coordinates of the cells referenced in the answer
-	 */
-	coordinates: number[][];
-}
+export type TableQuestionAnsweringArgs = BaseArgs & TableQuestionAnsweringInput;
 
 /**
  * Don’t know SQL? Don’t want to dive into a large spreadsheet? Ask questions in plain english! Recommended model: google/tapas-base-finetuned-wtq.
@@ -40,22 +11,35 @@ export interface TableQuestionAnsweringOutput {
 export async function tableQuestionAnswering(
 	args: TableQuestionAnsweringArgs,
 	options?: Options
-): Promise<TableQuestionAnsweringOutput> {
-	const res = await request<TableQuestionAnsweringOutput>(args, {
+): Promise<TableQuestionAnsweringOutput[number]> {
+	const res = await request<TableQuestionAnsweringOutput | TableQuestionAnsweringOutput[number]>(args, {
 		...options,
 		taskHint: "table-question-answering",
 	});
-	const isValidOutput =
-		typeof res?.aggregator === "string" &&
-		typeof res.answer === "string" &&
-		Array.isArray(res.cells) &&
-		res.cells.every((x) => typeof x === "string") &&
-		Array.isArray(res.coordinates) &&
-		res.coordinates.every((coord) => Array.isArray(coord) && coord.every((x) => typeof x === "number"));
+	const isValidOutput = Array.isArray(res) ? res.every((elem) => validate(elem)) : validate(res);
 	if (!isValidOutput) {
 		throw new InferenceOutputError(
 			"Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}"
 		);
 	}
-	return res;
+	return Array.isArray(res) ? res[0] : res;
+}
+
+function validate(elem: 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")
+		)
+	);
 }

package/src/tasks/nlp/textClassification.ts

@@ -1,24 +1,9 @@
+import type { TextClassificationInput, TextClassificationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
 import { request } from "../custom/request";
 
-export type TextClassificationArgs = BaseArgs & {
-	/**
-	 * A string to be classified
-	 */
-	inputs: string;
-};
-
-export type TextClassificationOutput = {
-	/**
-	 * The label for the class (model specific)
-	 */
-	label: string;
-	/**
-	 * A floats that represents how likely is that the text belongs to this class.
-	 */
-	score: number;
-}[];
+export type TextClassificationArgs = BaseArgs & TextClassificationInput;
 
 /**
  * Usually used for sentiment-analysis this will output the likelihood of classes of an input. Recommended model: distilbert-base-uncased-finetuned-sst-2-english
@@ -28,7 +13,7 @@ export async function textClassification(
 	options?: Options
 ): Promise<TextClassificationOutput> {
 	const res = (
-		await request<TextClassificationOutput[]>(args, {
+		await request<TextClassificationOutput>(args, {
 			...options,
 			taskHint: "text-classification",
 		})

package/src/tasks/nlp/tokenClassification.ts

@@ -1,55 +1,10 @@
+import type { TokenClassificationInput, TokenClassificationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
 import { toArray } from "../../utils/toArray";
 import { request } from "../custom/request";
 
-export type TokenClassificationArgs = BaseArgs & {
-	/**
-	 * A string to be classified
-	 */
-	inputs: string;
-	parameters?: {
-		/**
-		 * (Default: simple). There are several aggregation strategies:
-		 *
-		 * none: Every token gets classified without further aggregation.
-		 *
-		 * simple: Entities are grouped according to the default schema (B-, I- tags get merged when the tag is similar).
-		 *
-		 * first: Same as the simple strategy except words cannot end up with different tags. Words will use the tag of the first token when there is ambiguity.
-		 *
-		 * average: Same as the simple strategy except words cannot end up with different tags. Scores are averaged across tokens and then the maximum label is applied.
-		 *
-		 * max: Same as the simple strategy except words cannot end up with different tags. Word entity will be the token with the maximum score.
-		 */
-		aggregation_strategy?: "none" | "simple" | "first" | "average" | "max";
-	};
-};
-
-export interface TokenClassificationOutputValue {
-	/**
-	 * The offset stringwise where the answer is located. Useful to disambiguate if word occurs multiple times.
-	 */
-	end: number;
-	/**
-	 * The type for the entity being recognized (model specific).
-	 */
-	entity_group: string;
-	/**
-	 * How likely the entity was recognized.
-	 */
-	score: number;
-	/**
-	 * The offset stringwise where the answer is located. Useful to disambiguate if word occurs multiple times.
-	 */
-	start: number;
-	/**
-	 * The string that was captured
-	 */
-	word: string;
-}
-
-export type TokenClassificationOutput = TokenClassificationOutputValue[];
+export type TokenClassificationArgs = BaseArgs & TokenClassificationInput;
 
 /**
  * Usually used for sentence parsing, either grammatical, or Named Entity Recognition (NER) to understand keywords contained within text. Recommended model: dbmdz/bert-large-cased-finetuned-conll03-english

package/src/tasks/nlp/translation.ts

@@ -1,28 +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";
 
-export type TranslationArgs = BaseArgs & {
-	/**
-	 * A string to be translated
-	 */
-	inputs: string | string[];
-};
-
-export interface TranslationOutputValue {
-	/**
-	 * The string after translation
-	 */
-	translation_text: string;
-}
-
-export type TranslationOutput = TranslationOutputValue | TranslationOutputValue[];
-
+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<TranslationOutputValue[]>(args, {
+	const res = await request<TranslationOutput>(args, {
 		...options,
 		taskHint: "translation",
 	});

package/src/tasks/nlp/zeroShotClassification.ts

@@ -1,32 +1,10 @@
+import type { ZeroShotClassificationInput, ZeroShotClassificationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
 import { toArray } from "../../utils/toArray";
 import { request } from "../custom/request";
 
-export type ZeroShotClassificationArgs = BaseArgs & {
-	/**
-	 * a string or list of strings
-	 */
-	inputs: string | string[];
-	parameters: {
-		/**
-		 * a list of strings that are potential classes for inputs. (max 10 candidate_labels, for more, simply run multiple requests, results are going to be misleading if using too many candidate_labels anyway. If you want to keep the exact same, you can simply run multi_label=True and do the scaling on your end.
-		 */
-		candidate_labels: string[];
-		/**
-		 * (Default: false) Boolean that is set to True if classes can overlap
-		 */
-		multi_label?: boolean;
-	};
-};
-
-export interface ZeroShotClassificationOutputValue {
-	labels: string[];
-	scores: number[];
-	sequence: string;
-}
-
-export type ZeroShotClassificationOutput = ZeroShotClassificationOutputValue[];
+export type ZeroShotClassificationArgs = BaseArgs & ZeroShotClassificationInput;
 
 /**
  * This task is super useful to try out classification with zero code, you simply pass a sentence/paragraph and the possible labels for that sentence, and you get a result. Recommended model: facebook/bart-large-mnli.

package/src/types.ts

@@ -84,7 +84,13 @@ export interface BaseArgs {
 }
 
 export type RequestArgs = BaseArgs &
-	({ data: Blob | ArrayBuffer } | { inputs: unknown } | ChatCompletionInput) & {
+	(
+		| { data: Blob | ArrayBuffer }
+		| { inputs: unknown }
+		| { prompt: string }
+		| { audio_url: string }
+		| ChatCompletionInput
+	) & {
 		parameters?: Record<string, unknown>;
 		accessToken?: string;
 	};