@huggingface/inference 3.3.6 → 3.4.0

package/src/lib/makeRequestOptions.ts

@@ -1,15 +1,16 @@
 import { HF_HUB_URL, HF_ROUTER_URL } from "../config";
-import { FAL_AI_API_BASE_URL } from "../providers/fal-ai";
-import { NEBIUS_API_BASE_URL } from "../providers/nebius";
-import { REPLICATE_API_BASE_URL } from "../providers/replicate";
-import { SAMBANOVA_API_BASE_URL } from "../providers/sambanova";
-import { TOGETHER_API_BASE_URL } from "../providers/together";
-import { NOVITA_API_BASE_URL } from "../providers/novita";
-import { FIREWORKS_AI_API_BASE_URL } from "../providers/fireworks-ai";
-import { HYPERBOLIC_API_BASE_URL } from "../providers/hyperbolic";
-import { BLACKFORESTLABS_AI_API_BASE_URL } from "../providers/black-forest-labs";
-import type { InferenceProvider } from "../types";
-import type { InferenceTask, Options, RequestArgs } from "../types";
+import { BLACK_FOREST_LABS_CONFIG } from "../providers/black-forest-labs";
+import { COHERE_CONFIG } from "../providers/cohere";
+import { FAL_AI_CONFIG } from "../providers/fal-ai";
+import { FIREWORKS_AI_CONFIG } from "../providers/fireworks-ai";
+import { HF_INFERENCE_CONFIG } from "../providers/hf-inference";
+import { HYPERBOLIC_CONFIG } from "../providers/hyperbolic";
+import { NEBIUS_CONFIG } from "../providers/nebius";
+import { NOVITA_CONFIG } from "../providers/novita";
+import { REPLICATE_CONFIG } from "../providers/replicate";
+import { SAMBANOVA_CONFIG } from "../providers/sambanova";
+import { TOGETHER_CONFIG } from "../providers/together";
+import type { InferenceProvider, InferenceTask, Options, ProviderConfig, RequestArgs } from "../types";
 import { isUrl } from "./isUrl";
 import { version as packageVersion, name as packageName } from "../../package.json";
 import { getProviderModelId } from "./getProviderModelId";
@@ -22,6 +23,23 @@ const HF_HUB_INFERENCE_PROXY_TEMPLATE = `${HF_ROUTER_URL}/{{PROVIDER}}`;
  */
 let tasks: Record<string, { models: { id: string }[] }> | null = null;
 
+/**
+ * Config to define how to serialize requests for each provider
+ */
+const providerConfigs: Record<InferenceProvider, ProviderConfig> = {
+	"black-forest-labs": BLACK_FOREST_LABS_CONFIG,
+	cohere: COHERE_CONFIG,
+	"fal-ai": FAL_AI_CONFIG,
+	"fireworks-ai": FIREWORKS_AI_CONFIG,
+	"hf-inference": HF_INFERENCE_CONFIG,
+	hyperbolic: HYPERBOLIC_CONFIG,
+	nebius: NEBIUS_CONFIG,
+	novita: NOVITA_CONFIG,
+	replicate: REPLICATE_CONFIG,
+	sambanova: SAMBANOVA_CONFIG,
+	together: TOGETHER_CONFIG,
+};
+
 /**
  * Helper that prepares request arguments
  */
@@ -31,16 +49,16 @@ export async function makeRequestOptions(
 		stream?: boolean;
 	},
 	options?: Options & {
-		/** To load default model if needed */
-		taskHint?: InferenceTask;
+		/** In most cases (unless we pass a endpointUrl) we know the task */
+		task?: InferenceTask;
 		chatCompletion?: boolean;
 	}
 ): Promise<{ url: string; info: RequestInit }> {
 	const { accessToken, endpointUrl, provider: maybeProvider, model: maybeModel, ...remainingArgs } = args;
-	let otherArgs = remainingArgs;
 	const provider = maybeProvider ?? "hf-inference";
+	const providerConfig = providerConfigs[provider];
 
-	const { includeCredentials, taskHint, chatCompletion } = options ?? {};
+	const { includeCredentials, task, chatCompletion, signal } = options ?? {};
 
 	if (endpointUrl && provider !== "hf-inference") {
 		throw new Error(`Cannot use endpointUrl with a third-party provider.`);
@@ -48,13 +66,16 @@ export async function makeRequestOptions(
 	if (maybeModel && isUrl(maybeModel)) {
 		throw new Error(`Model URLs are no longer supported. Use endpointUrl instead.`);
 	}
-	if (!maybeModel && !taskHint) {
+	if (!maybeModel && !task) {
 		throw new Error("No model provided, and no task has been specified.");
 	}
+	if (!providerConfig) {
+		throw new Error(`No provider config found for provider ${provider}`);
+	}
 	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	const hfModel = maybeModel ?? (await loadDefaultModel(taskHint!));
+	const hfModel = maybeModel ?? (await loadDefaultModel(task!));
 	const model = await getProviderModelId({ model: hfModel, provider }, args, {
-		taskHint,
+		task,
 		chatCompletion,
 		fetch: options?.fetch,
 	});
@@ -68,44 +89,52 @@ export async function makeRequestOptions(
 		  ? "credentials-include"
 		  : "none";
 
+	// Make URL
 	const url = endpointUrl
 		? chatCompletion
 			? endpointUrl + `/v1/chat/completions`
 			: endpointUrl
-		: makeUrl({
-				authMethod,
-				chatCompletion: chatCompletion ?? false,
+		: providerConfig.makeUrl({
+				baseUrl:
+					authMethod !== "provider-key"
+						? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", provider)
+						: providerConfig.baseUrl,
 				model,
-				provider: provider ?? "hf-inference",
-				taskHint,
+				chatCompletion,
+				task,
 		  });
 
-	const headers: Record<string, string> = {};
-	if (accessToken) {
-		if (provider === "fal-ai" && authMethod === "provider-key") {
-			headers["Authorization"] = `Key ${accessToken}`;
-		} else if (provider === "black-forest-labs" && authMethod === "provider-key") {
-			headers["X-Key"] = accessToken;
-		} else {
-			headers["Authorization"] = `Bearer ${accessToken}`;
-		}
-	}
-
-	// e.g. @huggingface/inference/3.1.3
-	const ownUserAgent = `${packageName}/${packageVersion}`;
-	headers["User-Agent"] = [ownUserAgent, typeof navigator !== "undefined" ? navigator.userAgent : undefined]
-		.filter((x) => x !== undefined)
-		.join(" ");
-
+	// Make headers
 	const binary = "data" in args && !!args.data;
+	const headers = providerConfig.makeHeaders({
+		accessToken,
+		authMethod,
+	});
 
+	// Add content-type to headers
 	if (!binary) {
 		headers["Content-Type"] = "application/json";
 	}
 
-	if (provider === "replicate") {
-		headers["Prefer"] = "wait";
-	}
+	// Add user-agent to headers
+	// e.g. @huggingface/inference/3.1.3
+	const ownUserAgent = `${packageName}/${packageVersion}`;
+	const userAgent = [ownUserAgent, typeof navigator !== "undefined" ? navigator.userAgent : undefined]
+		.filter((x) => x !== undefined)
+		.join(" ");
+	headers["User-Agent"] = userAgent;
+
+	// Make body
+	const body = binary
+		? args.data
+		: JSON.stringify(
+				providerConfig.makeBody({
+					args: remainingArgs as Record<string, unknown>,
+					model,
+					task,
+					chatCompletion,
+				})
+		  );
 
 	/**
 	 * For edge runtimes, leave 'credentials' undefined, otherwise cloudflare workers will error
@@ -117,158 +146,17 @@ export async function makeRequestOptions(
 		credentials = "include";
 	}
 
-	/**
-	 * Replicate models wrap all inputs inside { input: ... }
-	 * Versioned Replicate models in the format `owner/model:version` expect the version in the body
-	 */
-	if (provider === "replicate") {
-		const version = model.includes(":") ? model.split(":")[1] : undefined;
-		(otherArgs as unknown) = { input: otherArgs, version };
-	}
-
 	const info: RequestInit = {
 		headers,
 		method: "POST",
-		body: binary
-			? args.data
-			: JSON.stringify({
-					...otherArgs,
-					...(taskHint === "text-to-image" && provider === "hyperbolic"
-						? { model_name: model }
-						: chatCompletion || provider === "together" || provider === "nebius" || provider === "hyperbolic"
-						  ? { model }
-						  : undefined),
-			  }),
+		body,
 		...(credentials ? { credentials } : undefined),
-		signal: options?.signal,
+		signal,
 	};
 
 	return { url, info };
 }
 
-function makeUrl(params: {
-	authMethod: "none" | "hf-token" | "credentials-include" | "provider-key";
-	chatCompletion: boolean;
-	model: string;
-	provider: InferenceProvider;
-	taskHint: InferenceTask | undefined;
-}): string {
-	if (params.authMethod === "none" && params.provider !== "hf-inference") {
-		throw new Error("Authentication is required when requesting a third-party provider. Please provide accessToken");
-	}
-
-	const shouldProxy = params.provider !== "hf-inference" && params.authMethod !== "provider-key";
-	switch (params.provider) {
-		case "black-forest-labs": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: BLACKFORESTLABS_AI_API_BASE_URL;
-			return `${baseUrl}/${params.model}`;
-		}
-		case "fal-ai": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: FAL_AI_API_BASE_URL;
-			return `${baseUrl}/${params.model}`;
-		}
-		case "nebius": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: NEBIUS_API_BASE_URL;
-
-			if (params.taskHint === "text-to-image") {
-				return `${baseUrl}/v1/images/generations`;
-			}
-			if (params.taskHint === "text-generation") {
-				if (params.chatCompletion) {
-					return `${baseUrl}/v1/chat/completions`;
-				}
-				return `${baseUrl}/v1/completions`;
-			}
-			return baseUrl;
-		}
-		case "replicate": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: REPLICATE_API_BASE_URL;
-			if (params.model.includes(":")) {
-				/// Versioned model
-				return `${baseUrl}/v1/predictions`;
-			}
-			/// Evergreen / Canonical model
-			return `${baseUrl}/v1/models/${params.model}/predictions`;
-		}
-		case "sambanova": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: SAMBANOVA_API_BASE_URL;
-			/// Sambanova API matches OpenAI-like APIs: model is defined in the request body
-			if (params.taskHint === "text-generation" && params.chatCompletion) {
-				return `${baseUrl}/v1/chat/completions`;
-			}
-			return baseUrl;
-		}
-		case "together": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: TOGETHER_API_BASE_URL;
-			/// Together API matches OpenAI-like APIs: model is defined in the request body
-			if (params.taskHint === "text-to-image") {
-				return `${baseUrl}/v1/images/generations`;
-			}
-			if (params.taskHint === "text-generation") {
-				if (params.chatCompletion) {
-					return `${baseUrl}/v1/chat/completions`;
-				}
-				return `${baseUrl}/v1/completions`;
-			}
-			return baseUrl;
-		}
-
-		case "fireworks-ai": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: FIREWORKS_AI_API_BASE_URL;
-			if (params.taskHint === "text-generation" && params.chatCompletion) {
-				return `${baseUrl}/v1/chat/completions`;
-			}
-			return baseUrl;
-		}
-		case "hyperbolic": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: HYPERBOLIC_API_BASE_URL;
-
-			if (params.taskHint === "text-to-image") {
-				return `${baseUrl}/v1/images/generations`;
-			}
-			return `${baseUrl}/v1/chat/completions`;
-		}
-		case "novita": {
-			const baseUrl = shouldProxy
-				? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider)
-				: NOVITA_API_BASE_URL;
-			if (params.taskHint === "text-generation") {
-				if (params.chatCompletion) {
-					return `${baseUrl}/chat/completions`;
-				}
-				return `${baseUrl}/completions`;
-			}
-			return baseUrl;
-		}
-		default: {
-			const baseUrl = HF_HUB_INFERENCE_PROXY_TEMPLATE.replaceAll("{{PROVIDER}}", "hf-inference");
-			if (params.taskHint && ["feature-extraction", "sentence-similarity"].includes(params.taskHint)) {
-				/// when deployed on hf-inference, those two tasks are automatically compatible with one another.
-				return `${baseUrl}/pipeline/${params.taskHint}/${params.model}`;
-			}
-			if (params.taskHint === "text-generation" && params.chatCompletion) {
-				return `${baseUrl}/models/${params.model}/v1/chat/completions`;
-			}
-			return `${baseUrl}/models/${params.model}`;
-		}
-	}
-}
 async function loadDefaultModel(task: InferenceTask): Promise<string> {
 	if (!tasks) {
 		tasks = await loadTaskInfo();

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

@@ -1,5 +1,3 @@
-export const BLACKFORESTLABS_AI_API_BASE_URL = "https://api.us1.bfl.ai/v1";
-
 /**
  * See the registered mapping of HF model ID => Black Forest Labs model ID here:
  *
@@ -16,3 +14,29 @@ export const BLACKFORESTLABS_AI_API_BASE_URL = "https://api.us1.bfl.ai/v1";
  *
  * Thanks!
  */
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+const BLACK_FOREST_LABS_AI_API_BASE_URL = "https://api.us1.bfl.ai/v1";
+
+const makeBody = (params: BodyParams): Record<string, unknown> => {
+	return params.args;
+};
+
+const makeHeaders = (params: HeaderParams): Record<string, string> => {
+	if (params.authMethod === "provider-key") {
+		return { "X-Key": `${params.accessToken}` };
+	} else {
+		return { Authorization: `Bearer ${params.accessToken}` };
+	}
+};
+
+const makeUrl = (params: UrlParams): string => {
+	return `${params.baseUrl}/${params.model}`;
+};
+
+export const BLACK_FOREST_LABS_CONFIG: ProviderConfig = {
+	baseUrl: BLACK_FOREST_LABS_AI_API_BASE_URL,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};

package/src/providers/cohere.ts

@@ -0,0 +1,42 @@
+/**
+ * See the registered mapping of HF model ID => Cohere model ID here:
+ *
+ * https://huggingface.co/api/partners/cohere/models
+ *
+ * This is a publicly available mapping.
+ *
+ * If you want to try to run inference for a new model locally before it's registered on huggingface.co,
+ * you can add it to the dictionary "HARDCODED_MODEL_ID_MAPPING" in consts.ts, for dev purposes.
+ *
+ * - If you work at Cohere and want to update this mapping, please use the model mapping API we provide on huggingface.co
+ * - If you're a community member and want to add a new supported HF model to Cohere, please open an issue on the present repo
+ * and we will tag Cohere team members.
+ *
+ * Thanks!
+ */
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+const COHERE_API_BASE_URL = "https://api.cohere.com";
+
+
+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 = {
+	baseUrl: COHERE_API_BASE_URL,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};

package/src/providers/consts.ts

@@ -17,13 +17,14 @@ export const HARDCODED_MODEL_ID_MAPPING: Record<InferenceProvider, Record<ModelI
 	 * "Qwen/Qwen2.5-Coder-32B-Instruct": "Qwen2.5-Coder-32B-Instruct",
 	 */
 	"black-forest-labs": {},
+	cohere: {},
 	"fal-ai": {},
 	"fireworks-ai": {},
 	"hf-inference": {},
 	hyperbolic: {},
 	nebius: {},
+	novita: {},
 	replicate: {},
 	sambanova: {},
 	together: {},
-	novita: {},
 };

package/src/providers/fal-ai.ts

@@ -1,5 +1,3 @@
-export const FAL_AI_API_BASE_URL = "https://fal.run";
-
 /**
  * See the registered mapping of HF model ID => Fal model ID here:
  *
@@ -16,3 +14,27 @@ export const FAL_AI_API_BASE_URL = "https://fal.run";
  *
  * Thanks!
  */
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+const FAL_AI_API_BASE_URL = "https://fal.run";
+
+const makeBody = (params: BodyParams): Record<string, unknown> => {
+	return params.args;
+};
+
+const makeHeaders = (params: HeaderParams): Record<string, string> => {
+	return {
+		Authorization: params.authMethod === "provider-key" ? `Key ${params.accessToken}` : `Bearer ${params.accessToken}`,
+	};
+};
+
+const makeUrl = (params: UrlParams): string => {
+	return `${params.baseUrl}/${params.model}`;
+};
+
+export const FAL_AI_CONFIG: ProviderConfig = {
+	baseUrl: FAL_AI_API_BASE_URL,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};

package/src/providers/fireworks-ai.ts

@@ -1,5 +1,3 @@
-export const FIREWORKS_AI_API_BASE_URL = "https://api.fireworks.ai/inference";
-
 /**
  * See the registered mapping of HF model ID => Fireworks model ID here:
  *
@@ -16,3 +14,31 @@ export const FIREWORKS_AI_API_BASE_URL = "https://api.fireworks.ai/inference";
  *
  * Thanks!
  */
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+const FIREWORKS_AI_API_BASE_URL = "https://api.fireworks.ai/inference";
+
+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.task === "text-generation" && params.chatCompletion) {
+		return `${params.baseUrl}/v1/chat/completions`;
+	}
+	return params.baseUrl;
+};
+
+export const FIREWORKS_AI_CONFIG: ProviderConfig = {
+	baseUrl: FIREWORKS_AI_API_BASE_URL,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};

package/src/providers/hf-inference.ts

@@ -0,0 +1,43 @@
+/**
+ * HF-Inference do not have a mapping since all models use IDs from the Hub.
+ *
+ * If you want to try to run inference for a new model locally before it's registered on huggingface.co,
+ * you can add it to the dictionary "HARDCODED_MODEL_ID_MAPPING" in consts.ts, for dev purposes.
+ *
+ * - If you work at HF and want to update this mapping, please use the model mapping API we provide on huggingface.co
+ * - If you're a community member and want to add a new supported HF model to HF, please open an issue on the present repo
+ * and we will tag HF team members.
+ *
+ * Thanks!
+ */
+import { HF_ROUTER_URL } from "../config";
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+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.task && ["feature-extraction", "sentence-similarity"].includes(params.task)) {
+		/// when deployed on hf-inference, those two tasks are automatically compatible with one another.
+		return `${params.baseUrl}/pipeline/${params.task}/${params.model}`;
+	}
+	if (params.task === "text-generation" && params.chatCompletion) {
+		return `${params.baseUrl}/models/${params.model}/v1/chat/completions`;
+	}
+	return `${params.baseUrl}/models/${params.model}`;
+};
+
+export const HF_INFERENCE_CONFIG: ProviderConfig = {
+	baseUrl: `${HF_ROUTER_URL}/hf-inference`,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};

package/src/providers/hyperbolic.ts

@@ -1,5 +1,3 @@
-export const HYPERBOLIC_API_BASE_URL = "https://api.hyperbolic.xyz";
-
 /**
  * See the registered mapping of HF model ID => Hyperbolic model ID here:
  *
@@ -16,3 +14,31 @@ export const HYPERBOLIC_API_BASE_URL = "https://api.hyperbolic.xyz";
  *
  * Thanks!
  */
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+const HYPERBOLIC_API_BASE_URL = "https://api.hyperbolic.xyz";
+
+const makeBody = (params: BodyParams): Record<string, unknown> => {
+	return {
+		...params.args,
+		...(params.task === "text-to-image" ? { model_name: params.model } : { model: params.model }),
+	};
+};
+
+const makeHeaders = (params: HeaderParams): Record<string, string> => {
+	return { Authorization: `Bearer ${params.accessToken}` };
+};
+
+const makeUrl = (params: UrlParams): string => {
+	if (params.task === "text-to-image") {
+		return `${params.baseUrl}/v1/images/generations`;
+	}
+	return `${params.baseUrl}/v1/chat/completions`;
+};
+
+export const HYPERBOLIC_CONFIG: ProviderConfig = {
+	baseUrl: HYPERBOLIC_API_BASE_URL,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};

package/src/providers/nebius.ts

@@ -1,5 +1,3 @@
-export const NEBIUS_API_BASE_URL = "https://api.studio.nebius.ai";
-
 /**
  * See the registered mapping of HF model ID => Nebius model ID here:
  *
@@ -16,3 +14,37 @@ export const NEBIUS_API_BASE_URL = "https://api.studio.nebius.ai";
  *
  * Thanks!
  */
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+const NEBIUS_API_BASE_URL = "https://api.studio.nebius.ai";
+
+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 => {
+	if (params.task === "text-to-image") {
+		return `${params.baseUrl}/v1/images/generations`;
+	}
+	if (params.task === "text-generation") {
+		if (params.chatCompletion) {
+			return `${params.baseUrl}/v1/chat/completions`;
+		}
+		return `${params.baseUrl}/v1/completions`;
+	}
+	return params.baseUrl;
+};
+
+export const NEBIUS_CONFIG: ProviderConfig = {
+	baseUrl: NEBIUS_API_BASE_URL,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};

package/src/providers/novita.ts

@@ -1,5 +1,3 @@
-export const NOVITA_API_BASE_URL = "https://api.novita.ai/v3/openai";
-
 /**
  * See the registered mapping of HF model ID => Novita model ID here:
  *
@@ -16,3 +14,34 @@ export const NOVITA_API_BASE_URL = "https://api.novita.ai/v3/openai";
  *
  * Thanks!
  */
+import type { ProviderConfig, UrlParams, HeaderParams, BodyParams } from "../types";
+
+const NOVITA_API_BASE_URL = "https://api.novita.ai/v3/openai";
+
+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.task === "text-generation") {
+		if (params.chatCompletion) {
+			return `${params.baseUrl}/chat/completions`;
+		}
+		return `${params.baseUrl}/completions`;
+	}
+	return params.baseUrl;
+};
+
+export const NOVITA_CONFIG: ProviderConfig = {
+	baseUrl: NOVITA_API_BASE_URL,
+	makeBody,
+	makeHeaders,
+	makeUrl,
+};