@huggingface/inference 3.6.2 → 3.7.1

package/src/providers/hyperbolic.ts

@@ -14,35 +14,113 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import type { ChatCompletionOutput, TextGenerationOutput } from "@huggingface/tasks";
+import { InferenceOutputError } from "../lib/InferenceOutputError";
+import type { BodyParams, UrlParams } from "../types";
+import { omit } from "../utils/omit";
+import {
+	BaseConversationalTask,
+	BaseTextGenerationTask,
+	TaskProviderHelper,
+	type TextToImageTaskHelper,
+} from "./providerHelper";
 
 const HYPERBOLIC_API_BASE_URL = "https://api.hyperbolic.xyz";
 
-const makeBaseUrl = (): string => {
-	return HYPERBOLIC_API_BASE_URL;
-};
-
-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 = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+export interface HyperbolicTextCompletionOutput extends Omit<ChatCompletionOutput, "choices"> {
+	choices: Array<{
+		message: { content: string };
+	}>;
+}
+
+interface HyperbolicTextToImageOutput {
+	images: Array<{ image: string }>;
+}
+
+export class HyperbolicConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("hyperbolic", HYPERBOLIC_API_BASE_URL);
+	}
+}
+
+export class HyperbolicTextGenerationTask extends BaseTextGenerationTask {
+	constructor() {
+		super("hyperbolic", HYPERBOLIC_API_BASE_URL);
+	}
+
+	override makeRoute(): string {
+		return "v1/chat/completions";
+	}
+
+	override preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			messages: [{ content: params.args.inputs, role: "user" }],
+			...(params.args.parameters
+				? {
+						max_tokens: (params.args.parameters as Record<string, unknown>).max_new_tokens,
+						...omit(params.args.parameters as Record<string, unknown>, "max_new_tokens"),
+				  }
+				: undefined),
+			...omit(params.args, ["inputs", "parameters"]),
+			model: params.model,
+		};
+	}
+
+	override async getResponse(response: HyperbolicTextCompletionOutput): Promise<TextGenerationOutput> {
+		if (
+			typeof response === "object" &&
+			"choices" in response &&
+			Array.isArray(response?.choices) &&
+			typeof response?.model === "string"
+		) {
+			const completion = response.choices[0];
+			return {
+				generated_text: completion.message.content,
+			};
+		}
+
+		throw new InferenceOutputError("Expected Hyperbolic text generation response format");
+	}
+}
+
+export class HyperbolicTextToImageTask extends TaskProviderHelper implements TextToImageTaskHelper {
+	constructor() {
+		super("hyperbolic", HYPERBOLIC_API_BASE_URL);
+	}
+
+	makeRoute(params: UrlParams): string {
+		void params;
+		return `/v1/images/generations`;
+	}
+
+	preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...omit(params.args, ["inputs", "parameters"]),
+			...(params.args.parameters as Record<string, unknown>),
+			prompt: params.args.inputs,
+			model_name: params.model,
+		};
+	}
+
+	async getResponse(
+		response: HyperbolicTextToImageOutput,
+		url?: string,
+		headers?: HeadersInit,
+		outputType?: "url" | "blob"
+	): Promise<string | Blob> {
+		if (
+			typeof response === "object" &&
+			"images" in response &&
+			Array.isArray(response.images) &&
+			response.images[0] &&
+			typeof response.images[0].image === "string"
+		) {
+			if (outputType === "url") {
+				return `data:image/jpeg;base64,${response.images[0].image}`;
+			}
+			return fetch(`data:image/jpeg;base64,${response.images[0].image}`).then((res) => res.blob());
+		}
+
+		throw new InferenceOutputError("Expected Hyperbolic text-to-image response format");
+	}
+}

package/src/providers/nebius.ts

@@ -14,41 +14,77 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import { InferenceOutputError } from "../lib/InferenceOutputError";
+import type { BodyParams, UrlParams } from "../types";
+import { omit } from "../utils/omit";
+import {
+	BaseConversationalTask,
+	BaseTextGenerationTask,
+	TaskProviderHelper,
+	type TextToImageTaskHelper,
+} from "./providerHelper";
 
 const NEBIUS_API_BASE_URL = "https://api.studio.nebius.ai";
 
-const makeBaseUrl = (): string => {
-	return NEBIUS_API_BASE_URL;
-};
+interface NebiusBase64ImageGeneration {
+	data: Array<{
+		b64_json: string;
+	}>;
+}
 
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return {
-		...params.args,
-		model: params.model,
-	};
-};
+export class NebiusConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("nebius", NEBIUS_API_BASE_URL);
+	}
+}
 
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return { Authorization: `Bearer ${params.accessToken}` };
-};
+export class NebiusTextGenerationTask extends BaseTextGenerationTask {
+	constructor() {
+		super("nebius", NEBIUS_API_BASE_URL);
+	}
+}
 
-const makeUrl = (params: UrlParams): string => {
-	if (params.task === "text-to-image") {
-		return `${params.baseUrl}/v1/images/generations`;
+export class NebiusTextToImageTask extends TaskProviderHelper implements TextToImageTaskHelper {
+	constructor() {
+		super("nebius", NEBIUS_API_BASE_URL);
 	}
-	if (params.chatCompletion) {
-		return `${params.baseUrl}/v1/chat/completions`;
+
+	preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...omit(params.args, ["inputs", "parameters"]),
+			...(params.args.parameters as Record<string, unknown>),
+			response_format: "b64_json",
+			prompt: params.args.inputs,
+			model: params.model,
+		};
 	}
-	if (params.task === "text-generation") {
-		return `${params.baseUrl}/v1/completions`;
+
+	makeRoute(params: UrlParams): string {
+		void params;
+		return "v1/images/generations";
+	}
+
+	async getResponse(
+		response: NebiusBase64ImageGeneration,
+		url?: string,
+		headers?: HeadersInit,
+		outputType?: "url" | "blob"
+	): Promise<string | Blob> {
+		if (
+			typeof response === "object" &&
+			"data" in response &&
+			Array.isArray(response.data) &&
+			response.data.length > 0 &&
+			"b64_json" in response.data[0] &&
+			typeof response.data[0].b64_json === "string"
+		) {
+			const base64Data = response.data[0].b64_json;
+			if (outputType === "url") {
+				return `data:image/jpeg;base64,${base64Data}`;
+			}
+			return fetch(`data:image/jpeg;base64,${base64Data}`).then((res) => res.blob());
+		}
+
+		throw new InferenceOutputError("Expected Nebius text-to-image response format");
 	}
-	return params.baseUrl;
-};
-
-export const NEBIUS_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+}

package/src/providers/novita.ts

@@ -14,38 +14,74 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import { InferenceOutputError } from "../lib/InferenceOutputError";
+import { isUrl } from "../lib/isUrl";
+import type { BodyParams, UrlParams } from "../types";
+import { omit } from "../utils/omit";
+import {
+	BaseConversationalTask,
+	BaseTextGenerationTask,
+	TaskProviderHelper,
+	type TextToVideoTaskHelper,
+} from "./providerHelper";
 
 const NOVITA_API_BASE_URL = "https://api.novita.ai";
-
-const makeBaseUrl = (): string => {
-	return NOVITA_API_BASE_URL;
-};
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return {
-		...params.args,
-		...(params.chatCompletion ? { model: params.model } : undefined),
+export interface NovitaOutput {
+	video: {
+		video_url: string;
 	};
-};
-
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return { Authorization: `Bearer ${params.accessToken}` };
-};
-
-const makeUrl = (params: UrlParams): string => {
-	if (params.chatCompletion) {
-		return `${params.baseUrl}/v3/openai/chat/completions`;
-	} else if (params.task === "text-generation") {
-		return `${params.baseUrl}/v3/openai/completions`;
-	} else if (params.task === "text-to-video") {
-		return `${params.baseUrl}/v3/hf/${params.model}`;
-	}
-	return params.baseUrl;
-};
-
-export const NOVITA_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+}
+export class NovitaTextGenerationTask extends BaseTextGenerationTask {
+	constructor() {
+		super("novita", NOVITA_API_BASE_URL);
+	}
+
+	override makeRoute(): string {
+		return "/v3/openai/chat/completions";
+	}
+}
+
+export class NovitaConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("novita", NOVITA_API_BASE_URL);
+	}
+
+	override makeRoute(): string {
+		return "/v3/openai/chat/completions";
+	}
+}
+export class NovitaTextToVideoTask extends TaskProviderHelper implements TextToVideoTaskHelper {
+	constructor() {
+		super("novita", NOVITA_API_BASE_URL);
+	}
+
+	makeRoute(params: UrlParams): string {
+		return `/v3/hf/${params.model}`;
+	}
+
+	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: NovitaOutput): Promise<Blob> {
+		const isValidOutput =
+			typeof response === "object" &&
+			!!response &&
+			"video" in response &&
+			typeof response.video === "object" &&
+			!!response.video &&
+			"video_url" in response.video &&
+			typeof response.video.video_url === "string" &&
+			isUrl(response.video.video_url);
+
+		if (!isValidOutput) {
+			throw new InferenceOutputError("Expected { video: { video_url: string } }");
+		}
+
+		const urlResponse = await fetch(response.video.video_url);
+		return await urlResponse.blob();
+	}
+}

package/src/providers/openai.ts

@@ -1,39 +1,13 @@
 /**
  * Special case: provider configuration for a private models provider (OpenAI in this case).
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import { BaseConversationalTask } from "./providerHelper";
 
 const OPENAI_API_BASE_URL = "https://api.openai.com";
 
-const makeBaseUrl = (): string => {
-	return OPENAI_API_BASE_URL;
-};
-
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	if (!params.chatCompletion) {
-		throw new Error("OpenAI only supports chat completions.");
+export class OpenAIConversationalTask extends BaseConversationalTask {
+	constructor() {
+		// Pass clientSideRoutingOnly: true to the constructor
+		super("openai", OPENAI_API_BASE_URL, true);
 	}
-	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.chatCompletion) {
-		throw new Error("OpenAI only supports chat completions.");
-	}
-	return `${params.baseUrl}/v1/chat/completions`;
-};
-
-export const OPENAI_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-	clientSideRoutingOnly: true,
-};
+}