@huggingface/inference 3.0.1 → 3.1.0

package/src/tasks/cv/objectDetection.ts

@@ -1,43 +1,18 @@
 import { request } from "../custom/request";
 import type { BaseArgs, Options } from "../../types";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
+import type { ObjectDetectionInput, ObjectDetectionOutput } from "@huggingface/tasks";
+import { preparePayload, type LegacyImageInput } from "./utils";
 
-export type ObjectDetectionArgs = BaseArgs & {
-	/**
-	 * Binary image data
-	 */
-	data: Blob | ArrayBuffer;
-};
-
-export interface ObjectDetectionOutputValue {
-	/**
-	 * A dict (with keys [xmin,ymin,xmax,ymax]) representing the bounding box of a detected object.
-	 */
-	box: {
-		xmax: number;
-		xmin: number;
-		ymax: number;
-		ymin: number;
-	};
-	/**
-	 * The label for the class (model specific) of a detected object.
-	 */
-	label: string;
-
-	/**
-	 * A float that represents how likely it is that the detected object belongs to the given class.
-	 */
-	score: number;
-}
-
-export type ObjectDetectionOutput = ObjectDetectionOutputValue[];
+export type ObjectDetectionArgs = BaseArgs & (ObjectDetectionInput | LegacyImageInput);
 
 /**
  * This task reads some image input and outputs the likelihood of classes & bounding boxes of detected objects.
  * Recommended model: facebook/detr-resnet-50
  */
 export async function objectDetection(args: ObjectDetectionArgs, options?: Options): Promise<ObjectDetectionOutput> {
-	const res = await request<ObjectDetectionOutput>(args, {
+	const payload = preparePayload(args);
+	const res = await request<ObjectDetectionOutput>(payload, {
 		...options,
 		taskHint: "object-detection",
 	});

package/src/tasks/cv/textToImage.ts

@@ -1,47 +1,10 @@
+import type { TextToImageInput, TextToImageOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
+import { omit } from "../../utils/omit";
 import { request } from "../custom/request";
 
-export type TextToImageArgs = BaseArgs & {
-	/**
-	 * The text to generate an image from
-	 */
-	inputs: string;
-
-	/**
-	 * Same param but for external providers like Together, Replicate
-	 */
-	prompt?: string;
-	response_format?: "base64";
-	input?: {
-		prompt: string;
-	};
-
-	parameters?: {
-		/**
-		 * An optional negative prompt for the image generation
-		 */
-		negative_prompt?: string;
-		/**
-		 * The height in pixels of the generated image
-		 */
-		height?: number;
-		/**
-		 * The width in pixels of the generated image
-		 */
-		width?: number;
-		/**
-		 * The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference.
-		 */
-		num_inference_steps?: number;
-		/**
-		 * Guidance scale: Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, usually at the expense of lower image quality.
-		 */
-		guidance_scale?: number;
-	};
-};
-
-export type TextToImageOutput = Blob;
+export type TextToImageArgs = BaseArgs & TextToImageInput;
 
 interface Base64ImageGeneration {
 	data: Array<{
@@ -56,16 +19,17 @@ interface OutputUrlImageGeneration {
  * This task reads some text input and outputs an image.
  * Recommended model: stabilityai/stable-diffusion-2
  */
-export async function textToImage(args: TextToImageArgs, options?: Options): Promise<TextToImageOutput> {
-	if (args.provider === "together" || args.provider === "fal-ai") {
-		args.prompt = args.inputs;
-		delete (args as unknown as { inputs: unknown }).inputs;
-		args.response_format = "base64";
-	} else if (args.provider === "replicate") {
-		args.prompt = args.inputs;
-		delete (args as unknown as { inputs: unknown }).inputs;
-	}
-	const res = await request<TextToImageOutput | Base64ImageGeneration | OutputUrlImageGeneration>(args, {
+export async function textToImage(args: TextToImageArgs, options?: Options): Promise<Blob> {
+	const payload =
+		args.provider === "together" || args.provider === "fal-ai" || args.provider === "replicate"
+			? {
+					...omit(args, ["inputs", "parameters"]),
+					...args.parameters,
+					...(args.provider !== "replicate" ? { response_format: "base64" } : undefined),
+					prompt: args.inputs,
+			  }
+			: args;
+	const res = await request<TextToImageOutput | Base64ImageGeneration | OutputUrlImageGeneration>(payload, {
 		...options,
 		taskHint: "text-to-image",
 	});

package/src/tasks/cv/textToVideo.ts

@@ -0,0 +1,67 @@
+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";
+
+export type TextToVideoArgs = BaseArgs & TextToVideoInput;
+
+export type TextToVideoOutput = Blob;
+
+interface FalAiOutput {
+	video: {
+		url: string;
+	};
+}
+
+interface ReplicateOutput {
+	output: string;
+}
+
+const SUPPORTED_PROVIDERS = ["fal-ai", "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"
+			? { ...omit(args, ["inputs", "parameters"]), ...args.parameters, prompt: args.inputs }
+			: args;
+	const res = await request<FalAiOutput | ReplicateOutput>(payload, {
+		...options,
+		taskHint: "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.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();
+	}
+}

package/src/tasks/cv/utils.ts

@@ -0,0 +1,13 @@
+import type { BaseArgs, RequestArgs } from "../../types";
+import { omit } from "../../utils/omit";
+
+/**
+ * @deprecated
+ */
+export interface LegacyImageInput {
+	data: Blob | ArrayBuffer;
+}
+
+export function preparePayload(args: BaseArgs & ({ inputs: Blob } | LegacyImageInput)): RequestArgs {
+	return "data" in args ? args : { ...omit(args, "inputs"), data: args.inputs };
+}

package/src/tasks/cv/zeroShotImageClassification.ts

@@ -3,28 +3,39 @@ 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";
 
-export type ZeroShotImageClassificationArgs = BaseArgs & {
-	inputs: {
-		/**
-		 * Binary image data
-		 */
-		image: Blob | ArrayBuffer;
-	};
-	parameters: {
-		/**
-		 * A list of strings that are potential classes for inputs. (max 10)
-		 */
-		candidate_labels: string[];
-	};
-};
-
-export interface ZeroShotImageClassificationOutputValue {
-	label: string;
-	score: number;
+/**
+ * @deprecated
+ */
+interface LegacyZeroShotImageClassificationInput {
+	inputs: { image: Blob | ArrayBuffer };
 }
 
-export type ZeroShotImageClassificationOutput = ZeroShotImageClassificationOutputValue[];
+export type ZeroShotImageClassificationArgs = BaseArgs &
+	(ZeroShotImageClassificationInput | LegacyZeroShotImageClassificationInput);
+
+async function preparePayload(args: ZeroShotImageClassificationArgs): Promise<RequestArgs> {
+	if (args.inputs instanceof Blob) {
+		return {
+			...args,
+			inputs: {
+				image: base64FromBytes(new Uint8Array(await args.inputs.arrayBuffer())),
+			},
+		};
+	} else {
+		return {
+			...args,
+			inputs: {
+				image: base64FromBytes(
+					new Uint8Array(
+						args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
+					)
+				),
+			},
+		};
+	}
+}
 
 /**
  * Classify an image to specified classes.
@@ -34,18 +45,8 @@ export async function zeroShotImageClassification(
 	args: ZeroShotImageClassificationArgs,
 	options?: Options
 ): Promise<ZeroShotImageClassificationOutput> {
-	const reqArgs: RequestArgs = {
-		...args,
-		inputs: {
-			image: base64FromBytes(
-				new Uint8Array(
-					args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
-				)
-			),
-		},
-	} as RequestArgs;
-
-	const res = await request<ZeroShotImageClassificationOutput>(reqArgs, {
+	const payload = await preparePayload(args);
+	const res = await request<ZeroShotImageClassificationOutput>(payload, {
 		...options,
 		taskHint: "zero-shot-image-classification",
 	});

package/src/tasks/multimodal/documentQuestionAnswering.ts

@@ -4,37 +4,15 @@ 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";
 
-export type DocumentQuestionAnsweringArgs = BaseArgs & {
-	inputs: {
-		/**
-		 * Raw image
-		 *
-		 * You can use native `File` in browsers, or `new Blob([buffer])` in node, or for a base64 image `new Blob([btoa(base64String)])`, or even `await (await fetch('...)).blob()`
-		 **/
-		image: Blob | ArrayBuffer;
-		question: string;
-	};
-};
-
-export interface DocumentQuestionAnsweringOutput {
-	/**
-	 * A string that’s the answer within the document.
-	 */
-	answer: string;
-	/**
-	 * ?
-	 */
-	end?: number;
-	/**
-	 * A float that represents how likely that the answer is correct
-	 */
-	score?: number;
-	/**
-	 * ?
-	 */
-	start?: number;
-}
+/// Override the type to properly set inputs.image as Blob
+export type DocumentQuestionAnsweringArgs = BaseArgs &
+	DocumentQuestionAnsweringInput & { inputs: DocumentQuestionAnsweringInputData & { image: Blob } };
 
 /**
  * Answers a question on a document image. Recommended model: impira/layoutlm-document-qa.
@@ -42,32 +20,36 @@ export interface DocumentQuestionAnsweringOutput {
 export async function documentQuestionAnswering(
 	args: DocumentQuestionAnsweringArgs,
 	options?: Options
-): Promise<DocumentQuestionAnsweringOutput> {
+): Promise<DocumentQuestionAnsweringOutput[number]> {
 	const reqArgs: RequestArgs = {
 		...args,
 		inputs: {
 			question: args.inputs.question,
 			// convert Blob or ArrayBuffer to base64
-			image: base64FromBytes(
-				new Uint8Array(
-					args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
-				)
-			),
+			image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer())),
 		},
 	} as RequestArgs;
 	const res = toArray(
-		await request<[DocumentQuestionAnsweringOutput] | DocumentQuestionAnsweringOutput>(reqArgs, {
+		await request<DocumentQuestionAnsweringOutput | DocumentQuestionAnsweringOutput[number]>(reqArgs, {
 			...options,
 			taskHint: "document-question-answering",
 		})
-	)?.[0];
+	);
+
 	const isValidOutput =
-		typeof res?.answer === "string" &&
-		(typeof res.end === "number" || typeof res.end === "undefined") &&
-		(typeof res.score === "number" || typeof res.score === "undefined") &&
-		(typeof res.start === "number" || typeof res.start === "undefined");
+		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;
+
+	return res[0];
 }

package/src/tasks/multimodal/visualQuestionAnswering.ts

@@ -1,30 +1,16 @@
+import type {
+	VisualQuestionAnsweringInput,
+	VisualQuestionAnsweringInputData,
+	VisualQuestionAnsweringOutput,
+} from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options, RequestArgs } from "../../types";
 import { base64FromBytes } from "../../utils/base64FromBytes";
 import { request } from "../custom/request";
 
-export type VisualQuestionAnsweringArgs = BaseArgs & {
-	inputs: {
-		/**
-		 * Raw image
-		 *
-		 * You can use native `File` in browsers, or `new Blob([buffer])` in node, or for a base64 image `new Blob([btoa(base64String)])`, or even `await (await fetch('...)).blob()`
-		 **/
-		image: Blob | ArrayBuffer;
-		question: string;
-	};
-};
-
-export interface VisualQuestionAnsweringOutput {
-	/**
-	 * A string that’s the answer to a visual question.
-	 */
-	answer: string;
-	/**
-	 * Answer correctness score.
-	 */
-	score: number;
-}
+/// Override the type to properly set inputs.image as Blob
+export type VisualQuestionAnsweringArgs = BaseArgs &
+	VisualQuestionAnsweringInput & { inputs: VisualQuestionAnsweringInputData & { image: Blob } };
 
 /**
  * Answers a question on an image. Recommended model: dandelin/vilt-b32-finetuned-vqa.
@@ -32,28 +18,26 @@ export interface VisualQuestionAnsweringOutput {
 export async function visualQuestionAnswering(
 	args: VisualQuestionAnsweringArgs,
 	options?: Options
-): Promise<VisualQuestionAnsweringOutput> {
+): Promise<VisualQuestionAnsweringOutput[number]> {
 	const reqArgs: RequestArgs = {
 		...args,
 		inputs: {
 			question: args.inputs.question,
 			// convert Blob or ArrayBuffer to base64
-			image: base64FromBytes(
-				new Uint8Array(
-					args.inputs.image instanceof ArrayBuffer ? args.inputs.image : await args.inputs.image.arrayBuffer()
-				)
-			),
+			image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer())),
 		},
 	} as RequestArgs;
-	const res = (
-		await request<[VisualQuestionAnsweringOutput]>(reqArgs, {
-			...options,
-			taskHint: "visual-question-answering",
-		})
-	)?.[0];
-	const isValidOutput = typeof res?.answer === "string" && typeof res.score === "number";
+	const res = await request<VisualQuestionAnsweringOutput>(reqArgs, {
+		...options,
+		taskHint: "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;
+	return res[0];
 }

package/src/tasks/nlp/fillMask.ts

@@ -1,29 +1,9 @@
+import type { FillMaskInput, FillMaskOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
 import { request } from "../custom/request";
 
-export type FillMaskArgs = BaseArgs & {
-	inputs: string;
-};
-
-export type FillMaskOutput = {
-	/**
-	 * The probability for this token.
-	 */
-	score: number;
-	/**
-	 * The actual sequence of tokens that ran against the model (may contain special tokens)
-	 */
-	sequence: string;
-	/**
-	 * The id of the token
-	 */
-	token: number;
-	/**
-	 * The string representation of the token
-	 */
-	token_str: string;
-}[];
+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.

package/src/tasks/nlp/questionAnswering.ts

@@ -1,32 +1,9 @@
+import type { QuestionAnsweringInput, QuestionAnsweringOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
 import { request } from "../custom/request";
 
-export type QuestionAnsweringArgs = BaseArgs & {
-	inputs: {
-		context: string;
-		question: string;
-	};
-};
-
-export interface QuestionAnsweringOutput {
-	/**
-	 * A string that’s the answer within the text.
-	 */
-	answer: string;
-	/**
-	 * The index (string wise) of the stop of the answer within context.
-	 */
-	end: number;
-	/**
-	 * A float that represents how likely that the answer is correct
-	 */
-	score: number;
-	/**
-	 * The index (string wise) of the start of the answer within context.
-	 */
-	start: number;
-}
+export type QuestionAnsweringArgs = BaseArgs & QuestionAnsweringInput;
 
 /**
  * Want to have a nice know-it-all bot that can answer any question?. Recommended model: deepset/roberta-base-squad2
@@ -34,20 +11,29 @@ export interface QuestionAnsweringOutput {
 export async function questionAnswering(
 	args: QuestionAnsweringArgs,
 	options?: Options
-): Promise<QuestionAnsweringOutput> {
-	const res = await request<QuestionAnsweringOutput>(args, {
+): Promise<QuestionAnsweringOutput[number]> {
+	const res = await request<QuestionAnsweringOutput | QuestionAnsweringOutput[number]>(args, {
 		...options,
 		taskHint: "question-answering",
 	});
-	const isValidOutput =
-		typeof res === "object" &&
-		!!res &&
-		typeof res.answer === "string" &&
-		typeof res.end === "number" &&
-		typeof res.score === "number" &&
-		typeof res.start === "number";
+	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 {answer: string, end: number, score: number, start: number}");
+		throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
 	}
-	return res;
+	return Array.isArray(res) ? res[0] : res;
 }

package/src/tasks/nlp/sentenceSimilarity.ts

@@ -1,22 +1,11 @@
+import type { SentenceSimilarityInput, SentenceSimilarityOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import { getDefaultTask } from "../../lib/getDefaultTask";
 import type { BaseArgs, Options } from "../../types";
 import { request } from "../custom/request";
+import { omit } from "../../utils/omit";
 
-export type SentenceSimilarityArgs = BaseArgs & {
-	/**
-	 * The inputs vary based on the model.
-	 *
-	 * For example when using sentence-transformers/paraphrase-xlm-r-multilingual-v1 the inputs will have a `source_sentence` string and
-	 * a `sentences` array of strings
-	 */
-	inputs: Record<string, unknown> | Record<string, unknown>[];
-};
-
-/**
- * Returned values are a list of floats
- */
-export type SentenceSimilarityOutput = number[];
+export type SentenceSimilarityArgs = BaseArgs & SentenceSimilarityInput;
 
 /**
  * Calculate the semantic similarity between one text and a list of other sentences by comparing their embeddings.
@@ -26,7 +15,7 @@ export async function sentenceSimilarity(
 	options?: Options
 ): Promise<SentenceSimilarityOutput> {
 	const defaultTask = args.model ? await getDefaultTask(args.model, args.accessToken, options) : undefined;
-	const res = await request<SentenceSimilarityOutput>(args, {
+	const res = await request<SentenceSimilarityOutput>(prepareInput(args), {
 		...options,
 		taskHint: "sentence-similarity",
 		...(defaultTask === "feature-extraction" && { forceTask: "sentence-similarity" }),
@@ -38,3 +27,11 @@ 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,50 +1,9 @@
+import type { SummarizationInput, SummarizationOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../../lib/InferenceOutputError";
 import type { BaseArgs, Options } from "../../types";
 import { request } from "../custom/request";
 
-export type SummarizationArgs = BaseArgs & {
-	/**
-	 * A string to be summarized
-	 */
-	inputs: string;
-	parameters?: {
-		/**
-		 * (Default: None). Integer to define the maximum length in tokens of the output summary.
-		 */
-		max_length?: number;
-		/**
-		 * (Default: None). Float (0-120.0). The amount of time in seconds that the query should take maximum. Network can cause some overhead so it will be a soft limit.
-		 */
-		max_time?: number;
-		/**
-		 * (Default: None). Integer to define the minimum length in tokens of the output summary.
-		 */
-		min_length?: number;
-		/**
-		 * (Default: None). Float (0.0-100.0). The more a token is used within generation the more it is penalized to not be picked in successive generation passes.
-		 */
-		repetition_penalty?: number;
-		/**
-		 * (Default: 1.0). Float (0.0-100.0). The temperature of the sampling operation. 1 means regular sampling, 0 means always take the highest score, 100.0 is getting closer to uniform probability.
-		 */
-		temperature?: number;
-		/**
-		 * (Default: None). Integer to define the top tokens considered within the sample operation to create new text.
-		 */
-		top_k?: number;
-		/**
-		 * (Default: None). Float to define the tokens that are within the sample operation of text generation. Add tokens in the sample for more probable to least probable until the sum of the probabilities is greater than top_p.
-		 */
-		top_p?: number;
-	};
-};
-
-export interface SummarizationOutput {
-	/**
-	 * The string after translation
-	 */
-	summary_text: string;
-}
+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.