@huggingface/inference 3.6.2 → 3.7.1

package/src/providers/black-forest-labs.ts

@@ -14,33 +14,84 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import { InferenceOutputError } from "../lib/InferenceOutputError";
+import type { BodyParams, HeaderParams, UrlParams } from "../types";
+import { delay } from "../utils/delay";
+import { omit } from "../utils/omit";
+import { TaskProviderHelper, type TextToImageTaskHelper } from "./providerHelper";
 
 const BLACK_FOREST_LABS_AI_API_BASE_URL = "https://api.us1.bfl.ai";
+interface BlackForestLabsResponse {
+	id: string;
+	polling_url: string;
+}
 
-const makeBaseUrl = (): string => {
-	return BLACK_FOREST_LABS_AI_API_BASE_URL;
-};
+export class BlackForestLabsTextToImageTask extends TaskProviderHelper implements TextToImageTaskHelper {
+	constructor() {
+		super("black-forest-labs", BLACK_FOREST_LABS_AI_API_BASE_URL);
+	}
 
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return params.args;
-};
+	preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...omit(params.args, ["inputs", "parameters"]),
+			...(params.args.parameters as Record<string, unknown>),
+			prompt: params.args.inputs,
+		};
+	}
 
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	if (params.authMethod === "provider-key") {
-		return { "X-Key": `${params.accessToken}` };
-	} else {
-		return { Authorization: `Bearer ${params.accessToken}` };
+	override prepareHeaders(params: HeaderParams, binary: boolean): Record<string, string> {
+		const headers: Record<string, string> = {
+			Authorization:
+				params.authMethod !== "provider-key" ? `Bearer ${params.accessToken}` : `X-Key ${params.accessToken}`,
+		};
+		if (!binary) {
+			headers["Content-Type"] = "application/json";
+		}
+		return headers;
 	}
-};
 
-const makeUrl = (params: UrlParams): string => {
-	return `${params.baseUrl}/v1/${params.model}`;
-};
+	makeRoute(params: UrlParams): string {
+		if (!params) {
+			throw new Error("Params are required");
+		}
+		return `/v1/${params.model}`;
+	}
 
-export const BLACK_FOREST_LABS_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+	async getResponse(
+		response: BlackForestLabsResponse,
+		url?: string,
+		headers?: HeadersInit,
+		outputType?: "url" | "blob"
+	): Promise<string | Blob> {
+		const urlObj = new URL(response.polling_url);
+		for (let step = 0; step < 5; step++) {
+			await delay(1000);
+			console.debug(`Polling Black Forest Labs API for the result... ${step + 1}/5`);
+			urlObj.searchParams.set("attempt", step.toString(10));
+			const resp = await fetch(urlObj, { headers: { "Content-Type": "application/json" } });
+			if (!resp.ok) {
+				throw new InferenceOutputError("Failed to fetch result from black forest labs API");
+			}
+			const payload = await resp.json();
+			if (
+				typeof payload === "object" &&
+				payload &&
+				"status" in payload &&
+				typeof payload.status === "string" &&
+				payload.status === "Ready" &&
+				"result" in payload &&
+				typeof payload.result === "object" &&
+				payload.result &&
+				"sample" in payload.result &&
+				typeof payload.result.sample === "string"
+			) {
+				if (outputType === "url") {
+					return payload.result.sample;
+				}
+				const image = await fetch(payload.result.sample);
+				return await image.blob();
+			}
+		}
+		throw new InferenceOutputError("Failed to fetch result from black forest labs API");
+	}
+}

package/src/providers/cerebras.ts

@@ -14,32 +14,11 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
 
-const CEREBRAS_API_BASE_URL = "https://api.cerebras.ai";
+import { BaseConversationalTask } from "./providerHelper";
 
-const makeBaseUrl = (): string => {
-	return CEREBRAS_API_BASE_URL;
-};
-
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return {
-		...params.args,
-		model: params.model,
-	};
-};
-
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return { Authorization: `Bearer ${params.accessToken}` };
-};
-
-const makeUrl = (params: UrlParams): string => {
-	return `${params.baseUrl}/v1/chat/completions`;
-};
-
-export const CEREBRAS_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+export class CerebrasConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("cerebras", "https://api.cerebras.ai");
+	}
+}

package/src/providers/cohere.ts

@@ -14,32 +14,13 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import { BaseConversationalTask } from "./providerHelper";
 
-const COHERE_API_BASE_URL = "https://api.cohere.com";
-
-const makeBaseUrl = (): string => {
-	return COHERE_API_BASE_URL;
-};
-
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return {
-		...params.args,
-		model: params.model,
-	};
-};
-
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return { Authorization: `Bearer ${params.accessToken}` };
-};
-
-const makeUrl = (params: UrlParams): string => {
-	return `${params.baseUrl}/compatibility/v1/chat/completions`;
-};
-
-export const COHERE_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+export class CohereConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("cohere", "https://api.cohere.com");
+	}
+	override makeRoute(): string {
+		return "/compatibility/v1/chat/completions";
+	}
+}

package/src/providers/fal-ai.ts

@@ -14,109 +14,227 @@
  *
  * Thanks!
  */
+import type { AutomaticSpeechRecognitionOutput } from "@huggingface/tasks";
 import { InferenceOutputError } from "../lib/InferenceOutputError";
 import { isUrl } from "../lib/isUrl";
-import type { BodyParams, HeaderParams, InferenceTask, ProviderConfig, UrlParams } from "../types";
+import type { BodyParams, HeaderParams, UrlParams } from "../types";
 import { delay } from "../utils/delay";
+import { omit } from "../utils/omit";
+import {
+	type AutomaticSpeechRecognitionTaskHelper,
+	TaskProviderHelper,
+	type TextToImageTaskHelper,
+	type TextToVideoTaskHelper,
+} from "./providerHelper";
 
-const FAL_AI_API_BASE_URL = "https://fal.run";
-const FAL_AI_API_BASE_URL_QUEUE = "https://queue.fal.run";
+export interface FalAiQueueOutput {
+	request_id: string;
+	status: string;
+	response_url: string;
+}
 
-const makeBaseUrl = (task?: InferenceTask): string => {
-	return task === "text-to-video" ? FAL_AI_API_BASE_URL_QUEUE : FAL_AI_API_BASE_URL;
-};
+interface FalAITextToImageOutput {
+	images: Array<{
+		url: string;
+	}>;
+}
 
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return params.args;
-};
+interface FalAIAutomaticSpeechRecognitionOutput {
+	text: string;
+}
 
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return {
-		Authorization: params.authMethod === "provider-key" ? `Key ${params.accessToken}` : `Bearer ${params.accessToken}`,
+interface FalAITextToSpeechOutput {
+	audio: {
+		url: string;
+		content_type: string;
 	};
-};
+}
+export const FAL_AI_SUPPORTED_BLOB_TYPES = ["audio/mpeg", "audio/mp4", "audio/wav", "audio/x-wav"];
 
-const makeUrl = (params: UrlParams): string => {
-	const baseUrl = `${params.baseUrl}/${params.model}`;
-	if (params.authMethod !== "provider-key" && params.task === "text-to-video") {
-		return `${baseUrl}?_subdomain=queue`;
+abstract class FalAITask extends TaskProviderHelper {
+	constructor(url?: string) {
+		super("fal-ai", url || "https://fal.run");
 	}
-	return baseUrl;
-};
 
-export const FAL_AI_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+	preparePayload(params: BodyParams): Record<string, unknown> {
+		return params.args;
+	}
+	makeRoute(params: UrlParams): string {
+		return `/${params.model}`;
+	}
+	override prepareHeaders(params: HeaderParams, binary: boolean): Record<string, string> {
+		const headers: Record<string, string> = {
+			Authorization:
+				params.authMethod !== "provider-key" ? `Bearer ${params.accessToken}` : `Key ${params.accessToken}`,
+		};
+		if (!binary) {
+			headers["Content-Type"] = "application/json";
+		}
+		return headers;
+	}
+}
 
-export interface FalAiQueueOutput {
-	request_id: string;
-	status: string;
-	response_url: string;
+export class FalAITextToImageTask extends FalAITask implements TextToImageTaskHelper {
+	override preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...omit(params.args, ["inputs", "parameters"]),
+			...(params.args.parameters as Record<string, unknown>),
+			sync_mode: true,
+			prompt: params.args.inputs,
+		};
+	}
+
+	override async getResponse(response: FalAITextToImageOutput, outputType?: "url" | "blob"): Promise<string | Blob> {
+		if (
+			typeof response === "object" &&
+			"images" in response &&
+			Array.isArray(response.images) &&
+			response.images.length > 0 &&
+			"url" in response.images[0] &&
+			typeof response.images[0].url === "string"
+		) {
+			if (outputType === "url") {
+				return response.images[0].url;
+			}
+			const urlResponse = await fetch(response.images[0].url);
+			return await urlResponse.blob();
+		}
+
+		throw new InferenceOutputError("Expected Fal.ai text-to-image response format");
+	}
 }
 
-export async function pollFalResponse(
-	res: FalAiQueueOutput,
-	url: string,
-	headers: Record<string, string>
-): Promise<Blob> {
-	const requestId = res.request_id;
-	if (!requestId) {
-		throw new InferenceOutputError("No request ID found in the response");
+export class FalAITextToVideoTask extends FalAITask implements TextToVideoTaskHelper {
+	constructor() {
+		super("https://queue.fal.run");
+	}
+	override makeRoute(params: UrlParams): string {
+		if (params.authMethod !== "provider-key") {
+			return `/${params.model}?_subdomain=queue`;
+		}
+		return `/${params.model}`;
 	}
-	let status = res.status;
+	override preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...omit(params.args, ["inputs", "parameters"]),
+			...(params.args.parameters as Record<string, unknown>),
+			prompt: params.args.inputs,
+		};
+	}
+
+	override async getResponse(
+		response: FalAiQueueOutput,
+		url?: string,
+		headers?: Record<string, string>
+	): Promise<Blob> {
+		if (!url || !headers) {
+			throw new InferenceOutputError("URL and headers are required for text-to-video task");
+		}
+		const requestId = response.request_id;
+		if (!requestId) {
+			throw new InferenceOutputError("No request ID found in the response");
+		}
+		let status = response.status;
 
-	const parsedUrl = new URL(url);
-	const baseUrl = `${parsedUrl.protocol}//${parsedUrl.host}${
-		parsedUrl.host === "router.huggingface.co" ? "/fal-ai" : ""
-	}`;
+		const parsedUrl = new URL(url);
+		const baseUrl = `${parsedUrl.protocol}//${parsedUrl.host}${
+			parsedUrl.host === "router.huggingface.co" ? "/fal-ai" : ""
+		}`;
 
-	// extracting the provider model id for status and result urls
-	// from the response as it might be different from the mapped model in `url`
-	const modelId = new URL(res.response_url).pathname;
-	const queryParams = parsedUrl.search;
+		// extracting the provider model id for status and result urls
+		// from the response as it might be different from the mapped model in `url`
+		const modelId = new URL(response.response_url).pathname;
+		const queryParams = parsedUrl.search;
 
-	const statusUrl = `${baseUrl}${modelId}/status${queryParams}`;
-	const resultUrl = `${baseUrl}${modelId}${queryParams}`;
+		const statusUrl = `${baseUrl}${modelId}/status${queryParams}`;
+		const resultUrl = `${baseUrl}${modelId}${queryParams}`;
 
-	while (status !== "COMPLETED") {
-		await delay(500);
-		const statusResponse = await fetch(statusUrl, { headers });
+		while (status !== "COMPLETED") {
+			await delay(500);
+			const statusResponse = await fetch(statusUrl, { headers });
 
-		if (!statusResponse.ok) {
-			throw new InferenceOutputError("Failed to fetch response status from fal-ai API");
+			if (!statusResponse.ok) {
+				throw new InferenceOutputError("Failed to fetch response status from fal-ai API");
+			}
+			try {
+				status = (await statusResponse.json()).status;
+			} catch (error) {
+				throw new InferenceOutputError("Failed to parse status response from fal-ai API");
+			}
 		}
+
+		const resultResponse = await fetch(resultUrl, { headers });
+		let result: unknown;
 		try {
-			status = (await statusResponse.json()).status;
+			result = await resultResponse.json();
 		} catch (error) {
-			throw new InferenceOutputError("Failed to parse status response from fal-ai API");
+			throw new InferenceOutputError("Failed to parse result response from fal-ai API");
+		}
+		if (
+			typeof result === "object" &&
+			!!result &&
+			"video" in result &&
+			typeof result.video === "object" &&
+			!!result.video &&
+			"url" in result.video &&
+			typeof result.video.url === "string" &&
+			isUrl(result.video.url)
+		) {
+			const urlResponse = await fetch(result.video.url);
+			return await urlResponse.blob();
+		} else {
+			throw new InferenceOutputError(
+				"Expected { video: { url: string } } result format, got instead: " + JSON.stringify(result)
+			);
+		}
+	}
+}
+
+export class FalAIAutomaticSpeechRecognitionTask extends FalAITask implements AutomaticSpeechRecognitionTaskHelper {
+	override prepareHeaders(params: HeaderParams, binary: boolean): Record<string, string> {
+		const headers = super.prepareHeaders(params, binary);
+		headers["Content-Type"] = "application/json";
+		return headers;
+	}
+	override async getResponse(response: unknown): Promise<AutomaticSpeechRecognitionOutput> {
+		const res = response as FalAIAutomaticSpeechRecognitionOutput;
+		if (typeof res?.text !== "string") {
+			throw new InferenceOutputError(
+				`Expected { text: string } format from Fal.ai Automatic Speech Recognition, got: ${JSON.stringify(response)}`
+			);
 		}
+		return { text: res.text };
 	}
+}
 
-	const resultResponse = await fetch(resultUrl, { headers });
-	let result: unknown;
-	try {
-		result = await resultResponse.json();
-	} catch (error) {
-		throw new InferenceOutputError("Failed to parse result response from fal-ai API");
+export class FalAITextToSpeechTask extends FalAITask {
+	override preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...omit(params.args, ["inputs", "parameters"]),
+			...(params.args.parameters as Record<string, unknown>),
+			lyrics: params.args.inputs,
+		};
 	}
-	if (
-		typeof result === "object" &&
-		!!result &&
-		"video" in result &&
-		typeof result.video === "object" &&
-		!!result.video &&
-		"url" in result.video &&
-		typeof result.video.url === "string" &&
-		isUrl(result.video.url)
-	) {
-		const urlResponse = await fetch(result.video.url);
-		return await urlResponse.blob();
-	} else {
-		throw new InferenceOutputError(
-			"Expected { video: { url: string } } result format, got instead: " + JSON.stringify(result)
-		);
+
+	override async getResponse(response: unknown): Promise<Blob> {
+		const res = response as FalAITextToSpeechOutput;
+		if (typeof res?.audio?.url !== "string") {
+			throw new InferenceOutputError(
+				`Expected { audio: { url: string } } format from Fal.ai Text-to-Speech, got: ${JSON.stringify(response)}`
+			);
+		}
+		try {
+			const urlResponse = await fetch(res.audio.url);
+			if (!urlResponse.ok) {
+				throw new Error(`Failed to fetch audio from ${res.audio.url}: ${urlResponse.statusText}`);
+			}
+			return await urlResponse.blob();
+		} catch (error) {
+			throw new InferenceOutputError(
+				`Error fetching or processing audio from Fal.ai Text-to-Speech URL: ${res.audio.url}. ${
+					error instanceof Error ? error.message : String(error)
+				}`
+			);
+		}
 	}
 }

package/src/providers/fireworks-ai.ts

@@ -14,35 +14,14 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import { BaseConversationalTask } from "./providerHelper";
 
-const FIREWORKS_AI_API_BASE_URL = "https://api.fireworks.ai";
-
-const makeBaseUrl = (): string => {
-	return FIREWORKS_AI_API_BASE_URL;
-};
-
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return {
-		...params.args,
-		...(params.chatCompletion ? { model: params.model } : undefined),
-	};
-};
-
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return { Authorization: `Bearer ${params.accessToken}` };
-};
-
-const makeUrl = (params: UrlParams): string => {
-	if (params.chatCompletion) {
-		return `${params.baseUrl}/inference/v1/chat/completions`;
+export class FireworksConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("fireworks-ai", "https://api.fireworks.ai");
 	}
-	return `${params.baseUrl}/inference`;
-};
 
-export const FIREWORKS_AI_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+	override makeRoute(): string {
+		return "/inference/v1/chat/completions";
+	}
+}