@huggingface/inference 3.7.0 → 3.8.0

package/src/providers/providerHelper.ts

@@ -0,0 +1,354 @@
+import type {
+	AudioClassificationInput,
+	AudioClassificationOutput,
+	AutomaticSpeechRecognitionInput,
+	AutomaticSpeechRecognitionOutput,
+	ChatCompletionInput,
+	ChatCompletionOutput,
+	DocumentQuestionAnsweringInput,
+	DocumentQuestionAnsweringOutput,
+	FeatureExtractionInput,
+	FeatureExtractionOutput,
+	FillMaskInput,
+	FillMaskOutput,
+	ImageClassificationInput,
+	ImageClassificationOutput,
+	ImageSegmentationInput,
+	ImageSegmentationOutput,
+	ImageToImageInput,
+	ImageToTextInput,
+	ImageToTextOutput,
+	ObjectDetectionInput,
+	ObjectDetectionOutput,
+	QuestionAnsweringInput,
+	QuestionAnsweringOutput,
+	SentenceSimilarityInput,
+	SentenceSimilarityOutput,
+	SummarizationInput,
+	SummarizationOutput,
+	TableQuestionAnsweringInput,
+	TableQuestionAnsweringOutput,
+	TextClassificationOutput,
+	TextGenerationInput,
+	TextGenerationOutput,
+	TextToImageInput,
+	TextToSpeechInput,
+	TextToVideoInput,
+	TokenClassificationInput,
+	TokenClassificationOutput,
+	TranslationInput,
+	TranslationOutput,
+	VisualQuestionAnsweringInput,
+	VisualQuestionAnsweringOutput,
+	ZeroShotClassificationInput,
+	ZeroShotClassificationOutput,
+	ZeroShotImageClassificationInput,
+	ZeroShotImageClassificationOutput,
+} from "@huggingface/tasks";
+import { HF_ROUTER_URL } from "../config";
+import { InferenceOutputError } from "../lib/InferenceOutputError";
+import type { AudioToAudioOutput } from "../tasks/audio/audioToAudio";
+import type { BaseArgs, BodyParams, HeaderParams, InferenceProvider, UrlParams } from "../types";
+import { toArray } from "../utils/toArray";
+
+/**
+ * Base class for task-specific provider helpers
+ */
+export abstract class TaskProviderHelper {
+	constructor(
+		private provider: InferenceProvider,
+		private baseUrl: string,
+		readonly clientSideRoutingOnly: boolean = false
+	) {}
+
+	/**
+	 * Return the response in the expected format.
+	 * Needs to be implemented in the subclasses.
+	 */
+	abstract getResponse(
+		response: unknown,
+		url?: string,
+		headers?: HeadersInit,
+		outputType?: "url" | "blob"
+	): Promise<unknown>;
+
+	/**
+	 * Prepare the route for the request
+	 * Needs to be implemented in the subclasses.
+	 */
+	abstract makeRoute(params: UrlParams): string;
+	/**
+	 * Prepare the payload for the request
+	 * Needs to be implemented in the subclasses.
+	 */
+	abstract preparePayload(params: BodyParams): unknown;
+
+	/**
+	 * Prepare the base URL for the request
+	 */
+	makeBaseUrl(params: UrlParams): string {
+		return params.authMethod !== "provider-key" ? `${HF_ROUTER_URL}/${this.provider}` : this.baseUrl;
+	}
+
+	/**
+	 * Prepare the body for the request
+	 */
+	makeBody(params: BodyParams): BodyInit {
+		if ("data" in params.args && !!params.args.data) {
+			return params.args.data as BodyInit;
+		}
+		return JSON.stringify(this.preparePayload(params));
+	}
+
+	/**
+	 * Prepare the URL for the request
+	 */
+	makeUrl(params: UrlParams): string {
+		const baseUrl = this.makeBaseUrl(params);
+		const route = this.makeRoute(params).replace(/^\/+/, "");
+		return `${baseUrl}/${route}`;
+	}
+
+	/**
+	 * Prepare the headers for the request
+	 */
+	prepareHeaders(params: HeaderParams, isBinary: boolean): Record<string, string> {
+		const headers: Record<string, string> = { Authorization: `Bearer ${params.accessToken}` };
+		if (!isBinary) {
+			headers["Content-Type"] = "application/json";
+		}
+		return headers;
+	}
+}
+
+// PER-TASK PROVIDER HELPER INTERFACES
+
+// CV Tasks
+export interface TextToImageTaskHelper {
+	getResponse(
+		response: unknown,
+		url?: string,
+		headers?: HeadersInit,
+		outputType?: "url" | "blob"
+	): Promise<string | Blob>;
+	preparePayload(params: BodyParams<TextToImageInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface TextToVideoTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: Record<string, string>): Promise<Blob>;
+	preparePayload(params: BodyParams<TextToVideoInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface ImageToImageTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<Blob>;
+	preparePayload(params: BodyParams<ImageToImageInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface ImageSegmentationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<ImageSegmentationOutput>;
+	preparePayload(params: BodyParams<ImageSegmentationInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+export interface ImageClassificationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<ImageClassificationOutput>;
+	preparePayload(params: BodyParams<ImageClassificationInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+export interface ObjectDetectionTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<ObjectDetectionOutput>;
+	preparePayload(params: BodyParams<ObjectDetectionInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+export interface ImageToTextTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<ImageToTextOutput>;
+	preparePayload(params: BodyParams<ImageToTextInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+export interface ZeroShotImageClassificationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<ZeroShotImageClassificationOutput>;
+	preparePayload(params: BodyParams<ZeroShotImageClassificationInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+// NLP Tasks
+export interface TextGenerationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<TextGenerationOutput>;
+	preparePayload(params: BodyParams<TextGenerationInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface ConversationalTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<ChatCompletionOutput>;
+	preparePayload(params: BodyParams<ChatCompletionInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface TextClassificationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<TextClassificationOutput>;
+	preparePayload(params: BodyParams<ZeroShotClassificationInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface QuestionAnsweringTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<QuestionAnsweringOutput[number]>;
+	preparePayload(params: BodyParams<QuestionAnsweringInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface FillMaskTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<FillMaskOutput>;
+	preparePayload(params: BodyParams<FillMaskInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface ZeroShotClassificationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<ZeroShotClassificationOutput>;
+	preparePayload(params: BodyParams<ZeroShotClassificationInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface SentenceSimilarityTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<SentenceSimilarityOutput>;
+	preparePayload(params: BodyParams<SentenceSimilarityInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface TableQuestionAnsweringTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<TableQuestionAnsweringOutput[number]>;
+	preparePayload(params: BodyParams<TableQuestionAnsweringInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface TokenClassificationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<TokenClassificationOutput>;
+	preparePayload(params: BodyParams<TokenClassificationInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface TranslationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<TranslationOutput>;
+	preparePayload(params: BodyParams<TranslationInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface SummarizationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<SummarizationOutput>;
+	preparePayload(params: BodyParams<SummarizationInput & BaseArgs>): Record<string, unknown>;
+}
+
+// Audio Tasks
+export interface TextToSpeechTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<Blob>;
+	preparePayload(params: BodyParams<TextToSpeechInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface TextToAudioTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<Blob>;
+	preparePayload(params: BodyParams<Record<string, unknown> & BaseArgs>): Record<string, unknown>;
+}
+
+export interface AudioToAudioTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<AudioToAudioOutput[]>;
+	preparePayload(
+		params: BodyParams<BaseArgs & { inputs: Blob } & Record<string, unknown>>
+	): Record<string, unknown> | BodyInit;
+}
+export interface AutomaticSpeechRecognitionTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<AutomaticSpeechRecognitionOutput>;
+	preparePayload(params: BodyParams<AutomaticSpeechRecognitionInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+export interface AudioClassificationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<AudioClassificationOutput>;
+	preparePayload(params: BodyParams<AudioClassificationInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+// Multimodal Tasks
+export interface DocumentQuestionAnsweringTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<DocumentQuestionAnsweringOutput[number]>;
+	preparePayload(params: BodyParams<DocumentQuestionAnsweringInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+export interface FeatureExtractionTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<FeatureExtractionOutput>;
+	preparePayload(params: BodyParams<FeatureExtractionInput & BaseArgs>): Record<string, unknown>;
+}
+
+export interface VisualQuestionAnsweringTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<VisualQuestionAnsweringOutput[number]>;
+	preparePayload(params: BodyParams<VisualQuestionAnsweringInput & BaseArgs>): Record<string, unknown> | BodyInit;
+}
+
+export interface TabularClassificationTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<number[]>;
+	preparePayload(
+		params: BodyParams<BaseArgs & { inputs: { data: Record<string, string[]> } } & Record<string, unknown>>
+	): Record<string, unknown> | BodyInit;
+}
+
+export interface TabularRegressionTaskHelper {
+	getResponse(response: unknown, url?: string, headers?: HeadersInit): Promise<number[]>;
+	preparePayload(
+		params: BodyParams<BaseArgs & { inputs: { data: Record<string, string[]> } } & Record<string, unknown>>
+	): Record<string, unknown> | BodyInit;
+}
+
+// BASE IMPLEMENTATIONS FOR COMMON PATTERNS
+
+export class BaseConversationalTask extends TaskProviderHelper implements ConversationalTaskHelper {
+	constructor(provider: InferenceProvider, baseUrl: string, clientSideRoutingOnly: boolean = false) {
+		super(provider, baseUrl, clientSideRoutingOnly);
+	}
+
+	makeRoute(): string {
+		return "v1/chat/completions";
+	}
+
+	preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...params.args,
+			model: params.model,
+		};
+	}
+
+	async getResponse(response: ChatCompletionOutput): Promise<ChatCompletionOutput> {
+		if (
+			typeof response === "object" &&
+			Array.isArray(response?.choices) &&
+			typeof response?.created === "number" &&
+			typeof response?.id === "string" &&
+			typeof response?.model === "string" &&
+			/// Together.ai and Nebius do not output a system_fingerprint
+			(response.system_fingerprint === undefined ||
+				response.system_fingerprint === null ||
+				typeof response.system_fingerprint === "string") &&
+			typeof response?.usage === "object"
+		) {
+			return response;
+		}
+
+		throw new InferenceOutputError("Expected ChatCompletionOutput");
+	}
+}
+
+export class BaseTextGenerationTask extends TaskProviderHelper implements TextGenerationTaskHelper {
+	constructor(provider: InferenceProvider, baseUrl: string, clientSideRoutingOnly: boolean = false) {
+		super(provider, baseUrl, clientSideRoutingOnly);
+	}
+
+	preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			...params.args,
+			model: params.model,
+		};
+	}
+
+	makeRoute(): string {
+		return "v1/completions";
+	}
+
+	async getResponse(response: unknown): Promise<TextGenerationOutput> {
+		const res = toArray(response);
+		if (
+			Array.isArray(res) &&
+			res.length > 0 &&
+			res.every(
+				(x): x is { generated_text: string } =>
+					typeof x === "object" && !!x && "generated_text" in x && typeof x.generated_text === "string"
+			)
+		) {
+			return res[0];
+		}
+
+		throw new InferenceOutputError("Expected Array<{generated_text: string}>");
+	}
+}

package/src/providers/replicate.ts

@@ -14,37 +14,127 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
-
-export const REPLICATE_API_BASE_URL = "https://api.replicate.com";
-
-const makeBaseUrl = (): string => {
-	return REPLICATE_API_BASE_URL;
-};
-
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return {
-		input: params.args,
-		version: params.model.includes(":") ? params.model.split(":")[1] : undefined,
-	};
-};
-
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return { Authorization: `Bearer ${params.accessToken}`, Prefer: "wait" };
-};
-
-const makeUrl = (params: UrlParams): string => {
-	if (params.model.includes(":")) {
-		/// Versioned model
-		return `${params.baseUrl}/v1/predictions`;
-	}
-	/// Evergreen / Canonical model
-	return `${params.baseUrl}/v1/models/${params.model}/predictions`;
-};
-
-export const REPLICATE_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+import { InferenceOutputError } from "../lib/InferenceOutputError";
+import { isUrl } from "../lib/isUrl";
+import type { BodyParams, HeaderParams, UrlParams } from "../types";
+import { omit } from "../utils/omit";
+import { TaskProviderHelper, type TextToImageTaskHelper, type TextToVideoTaskHelper } from "./providerHelper";
+
+export interface ReplicateOutput {
+	output?: string | string[];
+}
+
+abstract class ReplicateTask extends TaskProviderHelper {
+	constructor(url?: string) {
+		super("replicate", url || "https://api.replicate.com");
+	}
+
+	makeRoute(params: UrlParams): string {
+		if (params.model.includes(":")) {
+			return "v1/predictions";
+		}
+		return `v1/models/${params.model}/predictions`;
+	}
+	preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			input: {
+				...omit(params.args, ["inputs", "parameters"]),
+				...(params.args.parameters as Record<string, unknown>),
+				prompt: params.args.inputs,
+			},
+			version: params.model.includes(":") ? params.model.split(":")[1] : undefined,
+		};
+	}
+	override prepareHeaders(params: HeaderParams, binary: boolean): Record<string, string> {
+		const headers: Record<string, string> = { Authorization: `Bearer ${params.accessToken}`, Prefer: "wait" };
+		if (!binary) {
+			headers["Content-Type"] = "application/json";
+		}
+		return headers;
+	}
+
+	override makeUrl(params: UrlParams): string {
+		const baseUrl = this.makeBaseUrl(params);
+		if (params.model.includes(":")) {
+			return `${baseUrl}/v1/predictions`;
+		}
+		return `${baseUrl}/v1/models/${params.model}/predictions`;
+	}
+}
+
+export class ReplicateTextToImageTask extends ReplicateTask implements TextToImageTaskHelper {
+	override async getResponse(
+		res: ReplicateOutput | Blob,
+		url?: string,
+		headers?: Record<string, string>,
+		outputType?: "url" | "blob"
+	): Promise<string | Blob> {
+		void url;
+		void headers;
+		if (
+			typeof res === "object" &&
+			"output" in res &&
+			Array.isArray(res.output) &&
+			res.output.length > 0 &&
+			typeof res.output[0] === "string"
+		) {
+			if (outputType === "url") {
+				return res.output[0];
+			}
+			const urlResponse = await fetch(res.output[0]);
+			return await urlResponse.blob();
+		}
+
+		throw new InferenceOutputError("Expected Replicate text-to-image response format");
+	}
+}
+
+export class ReplicateTextToSpeechTask extends ReplicateTask {
+	override preparePayload(params: BodyParams): Record<string, unknown> {
+		const payload = super.preparePayload(params);
+
+		const input = payload["input"];
+		if (typeof input === "object" && input !== null && "prompt" in input) {
+			const inputObj = input as Record<string, unknown>;
+			inputObj["text"] = inputObj["prompt"];
+			delete inputObj["prompt"];
+		}
+
+		return payload;
+	}
+
+	override async getResponse(response: ReplicateOutput): Promise<Blob> {
+		if (response instanceof Blob) {
+			return response;
+		}
+		if (response && typeof response === "object") {
+			if ("output" in response) {
+				if (typeof response.output === "string") {
+					const urlResponse = await fetch(response.output);
+					return await urlResponse.blob();
+				} else if (Array.isArray(response.output)) {
+					const urlResponse = await fetch(response.output[0]);
+					return await urlResponse.blob();
+				}
+			}
+		}
+		throw new InferenceOutputError("Expected Blob or object with output");
+	}
+}
+
+export class ReplicateTextToVideoTask extends ReplicateTask implements TextToVideoTaskHelper {
+	override async getResponse(response: ReplicateOutput): Promise<Blob> {
+		if (
+			typeof response === "object" &&
+			!!response &&
+			"output" in response &&
+			typeof response.output === "string" &&
+			isUrl(response.output)
+		) {
+			const urlResponse = await fetch(response.output);
+			return await urlResponse.blob();
+		}
+
+		throw new InferenceOutputError("Expected { output: string }");
+	}
+}

package/src/providers/sambanova.ts

@@ -14,35 +14,10 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import { BaseConversationalTask } from "./providerHelper";
 
-const SAMBANOVA_API_BASE_URL = "https://api.sambanova.ai";
-
-const makeBaseUrl = (): string => {
-	return SAMBANOVA_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}/v1/chat/completions`;
+export class SambanovaConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("sambanova", "https://api.sambanova.ai");
 	}
-	return params.baseUrl;
-};
-
-export const SAMBANOVA_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+}

package/src/providers/together.ts

@@ -14,41 +14,105 @@
  *
  * Thanks!
  */
-import type { BodyParams, HeaderParams, ProviderConfig, UrlParams } from "../types";
+import type { ChatCompletionOutput, TextGenerationOutput, TextGenerationOutputFinishReason } from "@huggingface/tasks";
+import { InferenceOutputError } from "../lib/InferenceOutputError";
+import type { BodyParams } from "../types";
+import { omit } from "../utils/omit";
+import {
+	BaseConversationalTask,
+	BaseTextGenerationTask,
+	TaskProviderHelper,
+	type TextToImageTaskHelper,
+} from "./providerHelper";
 
 const TOGETHER_API_BASE_URL = "https://api.together.xyz";
 
-const makeBaseUrl = (): string => {
-	return TOGETHER_API_BASE_URL;
-};
+interface TogetherTextCompletionOutput extends Omit<ChatCompletionOutput, "choices"> {
+	choices: Array<{
+		text: string;
+		finish_reason: TextGenerationOutputFinishReason;
+		seed: number;
+		logprobs: unknown;
+		index: number;
+	}>;
+}
 
-const makeBody = (params: BodyParams): Record<string, unknown> => {
-	return {
-		...params.args,
-		model: params.model,
-	};
-};
+interface TogetherBase64ImageGeneration {
+	data: Array<{
+		b64_json: string;
+	}>;
+}
 
-const makeHeaders = (params: HeaderParams): Record<string, string> => {
-	return { Authorization: `Bearer ${params.accessToken}` };
-};
+export class TogetherConversationalTask extends BaseConversationalTask {
+	constructor() {
+		super("together", TOGETHER_API_BASE_URL);
+	}
+}
+
+export class TogetherTextGenerationTask extends BaseTextGenerationTask {
+	constructor() {
+		super("together", TOGETHER_API_BASE_URL);
+	}
 
-const makeUrl = (params: UrlParams): string => {
-	if (params.task === "text-to-image") {
-		return `${params.baseUrl}/v1/images/generations`;
+	override preparePayload(params: BodyParams): Record<string, unknown> {
+		return {
+			model: params.model,
+			...params.args,
+			prompt: params.args.inputs,
+		};
 	}
-	if (params.chatCompletion) {
-		return `${params.baseUrl}/v1/chat/completions`;
+
+	override async getResponse(response: TogetherTextCompletionOutput): 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.text,
+			};
+		}
+		throw new InferenceOutputError("Expected Together text generation response format");
 	}
-	if (params.task === "text-generation") {
-		return `${params.baseUrl}/v1/completions`;
+}
+
+export class TogetherTextToImageTask extends TaskProviderHelper implements TextToImageTaskHelper {
+	constructor() {
+		super("together", TOGETHER_API_BASE_URL);
 	}
-	return params.baseUrl;
-};
 
-export const TOGETHER_CONFIG: ProviderConfig = {
-	makeBaseUrl,
-	makeBody,
-	makeHeaders,
-	makeUrl,
-};
+	makeRoute(): string {
+		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,
+			response_format: "base64",
+			model: params.model,
+		};
+	}
+
+	async getResponse(response: TogetherBase64ImageGeneration, 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 Together text-to-image response format");
+	}
+}