Merge branch 'main' into feat/wavespeedai

Author: arabot777

README.md

@@ -97,7 +97,7 @@ You can run our packages with vanilla JS, without any bundler, by using a CDN or
 
 ```html
 <script type="module">
-    import { InferenceClient } from 'https://cdn.jsdelivr.net/npm/@huggingface/[email protected].3/+esm';
+    import { InferenceClient } from 'https://cdn.jsdelivr.net/npm/@huggingface/[email protected].4/+esm';
     import { createRepo, commit, deleteRepo, listFiles } from "https://cdn.jsdelivr.net/npm/@huggingface/[email protected]/+esm";
 </script>
 ```

packages/hub/src/lib/list-models.spec.ts

@@ -115,4 +115,23 @@ describe("listModels", () => {
 
 		expect(count).to.equal(10);
 	});
+
+	it("should list deepseek-ai models with inference provider mapping", async () => {
+		let count = 0;
+		for await (const entry of listModels({
+			search: { owner: "deepseek-ai" },
+			additionalFields: ["inferenceProviderMapping"],
+			limit: 1,
+		})) {
+			count++;
+			expect(entry.inferenceProviderMapping).to.be.an("array").that.is.not.empty;
+			for (const item of entry.inferenceProviderMapping ?? []) {
+				expect(item).to.have.property("provider").that.is.a("string").and.is.not.empty;
+				expect(item).to.have.property("hfModelId").that.is.a("string").and.is.not.empty;
+				expect(item).to.have.property("providerId").that.is.a("string").and.is.not.empty;
+			}
+		}
+
+		expect(count).to.equal(1);
+	});
 });

packages/hub/src/lib/list-models.ts

@@ -5,6 +5,7 @@ import type { CredentialsParams, PipelineType } from "../types/public";
 import { checkCredentials } from "../utils/checkCredentials";
 import { parseLinkHeader } from "../utils/parseLinkHeader";
 import { pick } from "../utils/pick";
+import { normalizeInferenceProviderMapping } from "../utils/normalizeInferenceProviderMapping";
 
 export const MODEL_EXPAND_KEYS = [
 	"pipeline_tag",
@@ -113,8 +114,20 @@ export async function* listModels<
 		const items: ApiModelInfo[] = await res.json();
 
 		for (const item of items) {
+			// Handle inferenceProviderMapping normalization
+			const normalizedItem = { ...item };
+			if (
+				(params?.additionalFields as string[])?.includes("inferenceProviderMapping") &&
+				item.inferenceProviderMapping
+			) {
+				normalizedItem.inferenceProviderMapping = normalizeInferenceProviderMapping(
+					item.id,
+					item.inferenceProviderMapping
+				);
+			}
+
 			yield {
-				...(params?.additionalFields && pick(item, params.additionalFields)),
+				...(params?.additionalFields && pick(normalizedItem, params.additionalFields)),
 				id: item._id,
 				name: item.id,
 				private: item.private,

packages/hub/src/lib/model-info.spec.ts

@@ -56,4 +56,20 @@ describe("modelInfo", () => {
 			sha: "f27b190eeac4c2302d24068eabf5e9d6044389ae",
 		});
 	});
+
+	it("should return model info deepseek-ai models with inference provider mapping", async () => {
+		const info = await modelInfo({
+			name: "deepseek-ai/DeepSeek-R1-0528",
+			additionalFields: ["inferenceProviderMapping"],
+		});
+
+		expect(info.inferenceProviderMapping).toBeDefined();
+		expect(info.inferenceProviderMapping).toBeInstanceOf(Array);
+		expect(info.inferenceProviderMapping?.length).toBeGreaterThan(0);
+		info.inferenceProviderMapping?.forEach((item) => {
+			expect(item).toHaveProperty("provider");
+			expect(item).toHaveProperty("hfModelId", "deepseek-ai/DeepSeek-R1-0528");
+			expect(item).toHaveProperty("providerId");
+		});
+	});
 });

packages/hub/src/lib/model-info.ts

@@ -4,6 +4,7 @@ import type { ApiModelInfo } from "../types/api/api-model";
 import type { CredentialsParams } from "../types/public";
 import { checkCredentials } from "../utils/checkCredentials";
 import { pick } from "../utils/pick";
+import { normalizeInferenceProviderMapping } from "../utils/normalizeInferenceProviderMapping";
 import { MODEL_EXPAND_KEYS, type MODEL_EXPANDABLE_KEYS, type ModelEntry } from "./list-models";
 
 export async function modelInfo<
@@ -48,8 +49,14 @@ export async function modelInfo<
 
 	const data = await response.json();
 
+	// Handle inferenceProviderMapping normalization
+	const normalizedData = { ...data };
+	if ((params?.additionalFields as string[])?.includes("inferenceProviderMapping") && data.inferenceProviderMapping) {
+		normalizedData.inferenceProviderMapping = normalizeInferenceProviderMapping(data.id, data.inferenceProviderMapping);
+	}
+
 	return {
-		...(params?.additionalFields && pick(data, params.additionalFields)),
+		...(params?.additionalFields && pick(normalizedData, params.additionalFields)),
 		id: data._id,
 		name: data.id,
 		private: data.private,

packages/hub/src/types/api/api-model.ts

@@ -18,9 +18,7 @@ export interface ApiModelInfo {
 	downloadsAllTime: number;
 	files: string[];
 	gitalyUid: string;
-	inferenceProviderMapping: Partial<
-		Record<string, { providerId: string; status: "live" | "staging"; task: WidgetType }>
-	>;
+	inferenceProviderMapping?: ApiModelInferenceProviderMappingEntry[];
 	lastAuthor: { email: string; user?: string };
 	lastModified: string; // convert to date
 	library_name?: ModelLibraryKey;
@@ -271,3 +269,14 @@ export interface ApiModelMetadata {
 	extra_gated_description?: string;
 	extra_gated_button_content?: string;
 }
+
+export interface ApiModelInferenceProviderMappingEntry {
+	provider: string; // Provider name
+	hfModelId: string; // ID of the model on the Hugging Face Hub
+	providerId: string; // ID of the model on the provider's side
+	status: "live" | "staging";
+	task: WidgetType;
+	adapter?: string;
+	adapterWeightsPath?: string;
+	type?: "single-file" | "tag-filter";
+}

packages/hub/src/utils/normalizeInferenceProviderMapping.ts

@@ -0,0 +1,36 @@
+import type { WidgetType } from "@huggingface/tasks";
+import type { ApiModelInferenceProviderMappingEntry } from "../types/api/api-model";
+
+/**
+ * Normalize inferenceProviderMapping to always return an array format.
+ *
+ * Little hack to simplify Inference Providers logic and make it backward and forward compatible.
+ * Right now, API returns a dict on model-info and a list on list-models. Let's harmonize to list.
+ */
+export function normalizeInferenceProviderMapping(
+	hfModelId: string,
+	inferenceProviderMapping?:
+		| ApiModelInferenceProviderMappingEntry[]
+		| Record<string, { providerId: string; status: "live" | "staging"; task: WidgetType }>
+): ApiModelInferenceProviderMappingEntry[] {
+	if (!inferenceProviderMapping) {
+		return [];
+	}
+
+	// If it's already an array, return it as is
+	if (Array.isArray(inferenceProviderMapping)) {
+		return inferenceProviderMapping.map((entry) => ({
+			...entry,
+			hfModelId,
+		}));
+	}
+
+	// Convert mapping to array format
+	return Object.entries(inferenceProviderMapping).map(([provider, mapping]) => ({
+		provider,
+		hfModelId,
+		providerId: mapping.providerId,
+		status: mapping.status,
+		task: mapping.task,
+	}));
+}

packages/inference/README.md

@@ -653,9 +653,10 @@ You can use any Chat Completion API-compatible provider with the `chatCompletion
 ```typescript
 // Chat Completion Example
 const MISTRAL_KEY = process.env.MISTRAL_KEY;
-const hf = new InferenceClient(MISTRAL_KEY);
-const ep = hf.endpoint("https://api.mistral.ai");
-const stream = ep.chatCompletionStream({
+const hf = new InferenceClient(MISTRAL_KEY, {
+  endpointUrl: "https://api.mistral.ai",
+});
+const stream = hf.chatCompletionStream({
   model: "mistral-tiny",
   messages: [{ role: "user", content: "Complete the equation one + one = , just the answer" }],
 });

packages/inference/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@huggingface/inference",
-	"version": "4.0.3",
+	"version": "4.0.4",
 	"packageManager": "[email protected]",
 	"license": "MIT",
 	"author": "Hugging Face and Tim Mikeladze <[email protected]>",

packages/inference/src/lib/getInferenceProviderMapping.ts

@@ -6,19 +6,48 @@ import type { InferenceProvider, InferenceProviderOrPolicy, ModelId } from "../t
 import { typedInclude } from "../utils/typedInclude.js";
 import { InferenceClientHubApiError, InferenceClientInputError } from "../errors.js";
 
-export const inferenceProviderMappingCache = new Map<ModelId, InferenceProviderMapping>();
+export const inferenceProviderMappingCache = new Map<ModelId, InferenceProviderMappingEntry[]>();
 
-export type InferenceProviderMapping = Partial<
-	Record<InferenceProvider, Omit<InferenceProviderModelMapping, "hfModelId">>
->;
-
-export interface InferenceProviderModelMapping {
+export interface InferenceProviderMappingEntry {
 	adapter?: string;
 	adapterWeightsPath?: string;
 	hfModelId: ModelId;
+	provider: string;
 	providerId: string;
 	status: "live" | "staging";
 	task: WidgetType;
+	type?: "single-model" | "tag-filter";
+}
+
+/**
+ * Normalize inferenceProviderMapping to always return an array format.
+ * This provides backward and forward compatibility for the API changes.
+ *
+ * Vendored from @huggingface/hub to avoid extra dependency.
+ */
+function normalizeInferenceProviderMapping(
+	modelId: ModelId,
+	inferenceProviderMapping?:
+		| InferenceProviderMappingEntry[]
+		| Record<string, { providerId: string; status: "live" | "staging"; task: WidgetType }>
+): InferenceProviderMappingEntry[] {
+	if (!inferenceProviderMapping) {
+		return [];
+	}
+
+	// If it's already an array, return it as is
+	if (Array.isArray(inferenceProviderMapping)) {
+		return inferenceProviderMapping;
+	}
+
+	// Convert mapping to array format
+	return Object.entries(inferenceProviderMapping).map(([provider, mapping]) => ({
+		provider,
+		hfModelId: modelId,
+		providerId: mapping.providerId,
+		status: mapping.status,
+		task: mapping.task,
+	}));
 }
 
 export async function fetchInferenceProviderMappingForModel(
@@ -27,8 +56,8 @@ export async function fetchInferenceProviderMappingForModel(
 	options?: {
 		fetch?: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
 	}
-): Promise<InferenceProviderMapping> {
-	let inferenceProviderMapping: InferenceProviderMapping | null;
+): Promise<InferenceProviderMappingEntry[]> {
+	let inferenceProviderMapping: InferenceProviderMappingEntry[] | null;
 	if (inferenceProviderMappingCache.has(modelId)) {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		inferenceProviderMapping = inferenceProviderMappingCache.get(modelId)!;
@@ -55,7 +84,11 @@ export async function fetchInferenceProviderMappingForModel(
 				);
 			}
 		}
-		let payload: { inferenceProviderMapping?: InferenceProviderMapping } | null = null;
+		let payload: {
+			inferenceProviderMapping?:
+				| InferenceProviderMappingEntry[]
+				| Record<string, { providerId: string; status: "live" | "staging"; task: WidgetType }>;
+		} | null = null;
 		try {
 			payload = await resp.json();
 		} catch {
@@ -72,7 +105,8 @@ export async function fetchInferenceProviderMappingForModel(
 				{ requestId: resp.headers.get("x-request-id") ?? "", status: resp.status, body: await resp.text() }
 			);
 		}
-		inferenceProviderMapping = payload.inferenceProviderMapping;
+		inferenceProviderMapping = normalizeInferenceProviderMapping(modelId, payload.inferenceProviderMapping);
+		inferenceProviderMappingCache.set(modelId, inferenceProviderMapping);
 	}
 	return inferenceProviderMapping;
 }
@@ -87,16 +121,12 @@ export async function getInferenceProviderMapping(
 	options: {
 		fetch?: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
 	}
-): Promise<InferenceProviderModelMapping | null> {
+): Promise<InferenceProviderMappingEntry | null> {
 	if (HARDCODED_MODEL_INFERENCE_MAPPING[params.provider][params.modelId]) {
 		return HARDCODED_MODEL_INFERENCE_MAPPING[params.provider][params.modelId];
 	}
-	const inferenceProviderMapping = await fetchInferenceProviderMappingForModel(
-		params.modelId,
-		params.accessToken,
-		options
-	);
-	const providerMapping = inferenceProviderMapping[params.provider];
+	const mappings = await fetchInferenceProviderMappingForModel(params.modelId, params.accessToken, options);
+	const providerMapping = mappings.find((mapping) => mapping.provider === params.provider);
 	if (providerMapping) {
 		const equivalentTasks =
 			params.provider === "hf-inference" && typedInclude(EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS, params.task)
@@ -112,7 +142,7 @@ export async function getInferenceProviderMapping(
 				`Model ${params.modelId} is in staging mode for provider ${params.provider}. Meant for test purposes only.`
 			);
 		}
-		return { ...providerMapping, hfModelId: params.modelId };
+		return providerMapping;
 	}
 	return null;
 }
@@ -139,8 +169,8 @@ export async function resolveProvider(
 		if (!modelId) {
 			throw new InferenceClientInputError("Specifying a model is required when provider is 'auto'");
 		}
-		const inferenceProviderMapping = await fetchInferenceProviderMappingForModel(modelId);
-		provider = Object.keys(inferenceProviderMapping)[0] as InferenceProvider | undefined;
+		const mappings = await fetchInferenceProviderMappingForModel(modelId);
+		provider = mappings[0]?.provider as InferenceProvider | undefined;
 	}
 	if (!provider) {
 		throw new InferenceClientInputError(`No Inference Provider available for model ${modelId}.`);