@huggingface/inference 4.11.2 → 4.12.0

package/src/providers/wavespeed.ts

@@ -0,0 +1,185 @@
+import type { TextToImageArgs } from "../tasks/cv/textToImage.js";
+import type { ImageToImageArgs } from "../tasks/cv/imageToImage.js";
+import type { TextToVideoArgs } from "../tasks/cv/textToVideo.js";
+import type { BodyParams, RequestArgs, UrlParams } from "../types.js";
+import { delay } from "../utils/delay.js";
+import { omit } from "../utils/omit.js";
+import { base64FromBytes } from "../utils/base64FromBytes.js";
+import type { TextToImageTaskHelper, TextToVideoTaskHelper, ImageToImageTaskHelper } from "./providerHelper.js";
+import { TaskProviderHelper } from "./providerHelper.js";
+import {
+	InferenceClientInputError,
+	InferenceClientProviderApiError,
+	InferenceClientProviderOutputError,
+} from "../errors.js";
+
+const WAVESPEEDAI_API_BASE_URL = "https://api.wavespeed.ai";
+
+/**
+ * Response structure for task status and results
+ */
+interface WaveSpeedAITaskResponse {
+	id: string;
+	model: string;
+	outputs: string[];
+	urls: {
+		get: string;
+	};
+	has_nsfw_contents: boolean[];
+	status: "created" | "processing" | "completed" | "failed";
+	created_at: string;
+	error: string;
+	executionTime: number;
+	timings: {
+		inference: number;
+	};
+}
+
+/**
+ * Response structure for initial task submission
+ */
+interface WaveSpeedAISubmitResponse {
+	id: string;
+	urls: {
+		get: string;
+	};
+}
+
+/**
+ * Response structure for WaveSpeed AI API
+ */
+interface WaveSpeedAIResponse {
+	code: number;
+	message: string;
+	data: WaveSpeedAITaskResponse;
+}
+
+/**
+ * Response structure for WaveSpeed AI API with submit response data
+ */
+interface WaveSpeedAISubmitTaskResponse {
+	code: number;
+	message: string;
+	data: WaveSpeedAISubmitResponse;
+}
+
+abstract class WavespeedAITask extends TaskProviderHelper {
+	constructor(url?: string) {
+		super("wavespeed", url || WAVESPEEDAI_API_BASE_URL);
+	}
+
+	makeRoute(params: UrlParams): string {
+		return `/api/v3/${params.model}`;
+	}
+
+	preparePayload(params: BodyParams<ImageToImageArgs | TextToImageArgs | TextToVideoArgs>): Record<string, unknown> {
+		const payload: Record<string, unknown> = {
+			...omit(params.args, ["inputs", "parameters"]),
+			...params.args.parameters,
+			prompt: params.args.inputs,
+		};
+		// Add LoRA support if adapter is specified in the mapping
+		if (params.mapping?.adapter === "lora") {
+			payload.loras = [
+				{
+					path: params.mapping.hfModelId,
+					scale: 1, // Default scale value
+				},
+			];
+		}
+		return payload;
+	}
+
+	override async getResponse(
+		response: WaveSpeedAISubmitTaskResponse,
+		url?: string,
+		headers?: Record<string, string>
+	): Promise<Blob> {
+		if (!headers) {
+			throw new InferenceClientInputError("Headers are required for WaveSpeed AI API calls");
+		}
+
+		const resultUrl = response.data.urls.get;
+
+		// Poll for results until completion
+		while (true) {
+			const resultResponse = await fetch(resultUrl, { headers });
+
+			if (!resultResponse.ok) {
+				throw new InferenceClientProviderApiError(
+					"Failed to fetch response status from WaveSpeed AI API",
+					{ url: resultUrl, method: "GET" },
+					{
+						requestId: resultResponse.headers.get("x-request-id") ?? "",
+						status: resultResponse.status,
+						body: await resultResponse.text(),
+					}
+				);
+			}
+
+			const result: WaveSpeedAIResponse = await resultResponse.json();
+			const taskResult = result.data;
+
+			switch (taskResult.status) {
+				case "completed": {
+					// Get the media data from the first output URL
+					if (!taskResult.outputs?.[0]) {
+						throw new InferenceClientProviderOutputError(
+							"Received malformed response from WaveSpeed AI API: No output URL in completed response"
+						);
+					}
+					const mediaResponse = await fetch(taskResult.outputs[0]);
+					if (!mediaResponse.ok) {
+						throw new InferenceClientProviderApiError(
+							"Failed to fetch generation output from WaveSpeed AI API",
+							{ url: taskResult.outputs[0], method: "GET" },
+							{
+								requestId: mediaResponse.headers.get("x-request-id") ?? "",
+								status: mediaResponse.status,
+								body: await mediaResponse.text(),
+							}
+						);
+					}
+					return await mediaResponse.blob();
+				}
+				case "failed": {
+					throw new InferenceClientProviderOutputError(taskResult.error || "Task failed");
+				}
+
+				default: {
+					// Wait before polling again
+					await delay(500);
+					continue;
+				}
+			}
+		}
+	}
+}
+
+export class WavespeedAITextToImageTask extends WavespeedAITask implements TextToImageTaskHelper {
+	constructor() {
+		super(WAVESPEEDAI_API_BASE_URL);
+	}
+}
+
+export class WavespeedAITextToVideoTask extends WavespeedAITask implements TextToVideoTaskHelper {
+	constructor() {
+		super(WAVESPEEDAI_API_BASE_URL);
+	}
+}
+
+export class WavespeedAIImageToImageTask extends WavespeedAITask implements ImageToImageTaskHelper {
+	constructor() {
+		super(WAVESPEEDAI_API_BASE_URL);
+	}
+
+	async preparePayloadAsync(args: ImageToImageArgs): Promise<RequestArgs> {
+		return {
+			...args,
+			inputs: args.parameters?.prompt,
+			image: base64FromBytes(
+				new Uint8Array(args.inputs instanceof ArrayBuffer ? args.inputs : await (args.inputs as Blob).arrayBuffer())
+			),
+		};
+	}
+}

package/src/tasks/nlp/chatCompletion.ts

@@ -3,6 +3,8 @@ import { resolveProvider } from "../../lib/getInferenceProviderMapping.js";
 import { getProviderHelper } from "../../lib/getProviderHelper.js";
 import type { BaseArgs, Options } from "../../types.js";
 import { innerRequest } from "../../utils/request.js";
+import type { ConversationalTaskHelper, TaskProviderHelper } from "../../providers/providerHelper.js";
+import { AutoRouterConversationalTask } from "../../providers/providerHelper.js";
 
 /**
  * Use the chat completion endpoint to generate a response to a prompt, using OpenAI message completion API no stream
@@ -11,8 +13,14 @@ export async function chatCompletion(
 	args: BaseArgs & ChatCompletionInput,
 	options?: Options
 ): Promise<ChatCompletionOutput> {
-	const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
-	const providerHelper = getProviderHelper(provider, "conversational");
+	let providerHelper: ConversationalTaskHelper & TaskProviderHelper;
+	if (!args.provider || args.provider === "auto") {
+		// Special case: we have a dedicated auto-router for conversational models. No need to fetch provider mapping.
+		providerHelper = new AutoRouterConversationalTask();
+	} else {
+		const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+		providerHelper = getProviderHelper(provider, "conversational");
+	}
 	const { data: response } = await innerRequest<ChatCompletionOutput>(args, providerHelper, {
 		...options,
 		task: "conversational",

package/src/types.ts

@@ -66,6 +66,7 @@ export const INFERENCE_PROVIDERS = [
 	"sambanova",
 	"scaleway",
 	"together",
+	"wavespeed",
 	"zai-org",
 ] as const;
 
@@ -75,6 +76,37 @@ export type InferenceProvider = (typeof INFERENCE_PROVIDERS)[number];
 
 export type InferenceProviderOrPolicy = (typeof PROVIDERS_OR_POLICIES)[number];
 
+/**
+ * The org namespace on the HF Hub i.e. hf.co/…
+ *
+ * Whenever possible, InferenceProvider should == org namespace
+ */
+export const PROVIDERS_HUB_ORGS: Record<InferenceProvider, string> = {
+	baseten: "baseten",
+	"black-forest-labs": "black-forest-labs",
+	cerebras: "cerebras",
+	clarifai: "clarifai",
+	cohere: "CohereLabs",
+	"fal-ai": "fal",
+	"featherless-ai": "featherless-ai",
+	"fireworks-ai": "fireworks-ai",
+	groq: "groq",
+	"hf-inference": "hf-inference",
+	hyperbolic: "Hyperbolic",
+	nebius: "nebius",
+	novita: "novita",
+	nscale: "nscale",
+	openai: "openai",
+	ovhcloud: "ovhcloud",
+	publicai: "publicai",
+	replicate: "replicate",
+	sambanova: "sambanovasystems",
+	scaleway: "scaleway",
+	together: "togethercomputer",
+	wavespeed: "wavespeed",
+	"zai-org": "zai-org",
+};
+
 export interface InferenceProviderMappingEntry {
 	adapter?: string;
 	adapterWeightsPath?: string;