@huggingface/inference 3.7.0 → 3.8.0

package/dist/index.js

@@ -41,91 +41,211 @@ __export(tasks_exports, {
   zeroShotImageClassification: () => zeroShotImageClassification
 });
 
+// src/lib/InferenceOutputError.ts
+var InferenceOutputError = class extends TypeError {
+  constructor(message) {
+    super(
+      `Invalid inference output: ${message}. Use the 'request' method with the same parameters to do a custom call with no type checking.`
+    );
+    this.name = "InferenceOutputError";
+  }
+};
+
+// src/utils/delay.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+// src/utils/pick.ts
+function pick(o, props) {
+  return Object.assign(
+    {},
+    ...props.map((prop) => {
+      if (o[prop] !== void 0) {
+        return { [prop]: o[prop] };
+      }
+    })
+  );
+}
+
+// src/utils/typedInclude.ts
+function typedInclude(arr, v) {
+  return arr.includes(v);
+}
+
+// src/utils/omit.ts
+function omit(o, props) {
+  const propsArr = Array.isArray(props) ? props : [props];
+  const letsKeep = Object.keys(o).filter((prop) => !typedInclude(propsArr, prop));
+  return pick(o, letsKeep);
+}
+
 // src/config.ts
 var HF_HUB_URL = "https://huggingface.co";
 var HF_ROUTER_URL = "https://router.huggingface.co";
 var HF_HEADER_X_BILL_TO = "X-HF-Bill-To";
 
-// src/providers/black-forest-labs.ts
-var BLACK_FOREST_LABS_AI_API_BASE_URL = "https://api.us1.bfl.ai";
-var makeBaseUrl = () => {
-  return BLACK_FOREST_LABS_AI_API_BASE_URL;
-};
-var makeBody = (params) => {
-  return params.args;
+// src/utils/toArray.ts
+function toArray(obj) {
+  if (Array.isArray(obj)) {
+    return obj;
+  }
+  return [obj];
+}
+
+// src/providers/providerHelper.ts
+var TaskProviderHelper = class {
+  constructor(provider, baseUrl, clientSideRoutingOnly = false) {
+    this.provider = provider;
+    this.baseUrl = baseUrl;
+    this.clientSideRoutingOnly = clientSideRoutingOnly;
+  }
+  /**
+   * Prepare the base URL for the request
+   */
+  makeBaseUrl(params) {
+    return params.authMethod !== "provider-key" ? `${HF_ROUTER_URL}/${this.provider}` : this.baseUrl;
+  }
+  /**
+   * Prepare the body for the request
+   */
+  makeBody(params) {
+    if ("data" in params.args && !!params.args.data) {
+      return params.args.data;
+    }
+    return JSON.stringify(this.preparePayload(params));
+  }
+  /**
+   * Prepare the URL for the request
+   */
+  makeUrl(params) {
+    const baseUrl = this.makeBaseUrl(params);
+    const route = this.makeRoute(params).replace(/^\/+/, "");
+    return `${baseUrl}/${route}`;
+  }
+  /**
+   * Prepare the headers for the request
+   */
+  prepareHeaders(params, isBinary) {
+    const headers = { Authorization: `Bearer ${params.accessToken}` };
+    if (!isBinary) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
 };
-var makeHeaders = (params) => {
-  if (params.authMethod === "provider-key") {
-    return { "X-Key": `${params.accessToken}` };
-  } else {
-    return { Authorization: `Bearer ${params.accessToken}` };
+var BaseConversationalTask = class extends TaskProviderHelper {
+  constructor(provider, baseUrl, clientSideRoutingOnly = false) {
+    super(provider, baseUrl, clientSideRoutingOnly);
+  }
+  makeRoute() {
+    return "v1/chat/completions";
+  }
+  preparePayload(params) {
+    return {
+      ...params.args,
+      model: params.model
+    };
+  }
+  async getResponse(response) {
+    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 === void 0 || response.system_fingerprint === null || typeof response.system_fingerprint === "string") && typeof response?.usage === "object") {
+      return response;
+    }
+    throw new InferenceOutputError("Expected ChatCompletionOutput");
   }
 };
-var makeUrl = (params) => {
-  return `${params.baseUrl}/v1/${params.model}`;
+var BaseTextGenerationTask = class extends TaskProviderHelper {
+  constructor(provider, baseUrl, clientSideRoutingOnly = false) {
+    super(provider, baseUrl, clientSideRoutingOnly);
+  }
+  preparePayload(params) {
+    return {
+      ...params.args,
+      model: params.model
+    };
+  }
+  makeRoute() {
+    return "v1/completions";
+  }
+  async getResponse(response) {
+    const res = toArray(response);
+    if (Array.isArray(res) && res.length > 0 && res.every(
+      (x) => typeof x === "object" && !!x && "generated_text" in x && typeof x.generated_text === "string"
+    )) {
+      return res[0];
+    }
+    throw new InferenceOutputError("Expected Array<{generated_text: string}>");
+  }
 };
-var BLACK_FOREST_LABS_CONFIG = {
-  makeBaseUrl,
-  makeBody,
-  makeHeaders,
-  makeUrl
+
+// src/providers/black-forest-labs.ts
+var BLACK_FOREST_LABS_AI_API_BASE_URL = "https://api.us1.bfl.ai";
+var BlackForestLabsTextToImageTask = class extends TaskProviderHelper {
+  constructor() {
+    super("black-forest-labs", BLACK_FOREST_LABS_AI_API_BASE_URL);
+  }
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      prompt: params.args.inputs
+    };
+  }
+  prepareHeaders(params, binary) {
+    const headers = {
+      Authorization: params.authMethod !== "provider-key" ? `Bearer ${params.accessToken}` : `X-Key ${params.accessToken}`
+    };
+    if (!binary) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  makeRoute(params) {
+    if (!params) {
+      throw new Error("Params are required");
+    }
+    return `/v1/${params.model}`;
+  }
+  async getResponse(response, url, headers, outputType) {
+    const urlObj = new URL(response.polling_url);
+    for (let step = 0; step < 5; step++) {
+      await delay(1e3);
+      console.debug(`Polling Black Forest Labs API for the result... ${step + 1}/5`);
+      urlObj.searchParams.set("attempt", step.toString(10));
+      const resp = await fetch(urlObj, { headers: { "Content-Type": "application/json" } });
+      if (!resp.ok) {
+        throw new InferenceOutputError("Failed to fetch result from black forest labs API");
+      }
+      const payload = await resp.json();
+      if (typeof payload === "object" && payload && "status" in payload && typeof payload.status === "string" && payload.status === "Ready" && "result" in payload && typeof payload.result === "object" && payload.result && "sample" in payload.result && typeof payload.result.sample === "string") {
+        if (outputType === "url") {
+          return payload.result.sample;
+        }
+        const image = await fetch(payload.result.sample);
+        return await image.blob();
+      }
+    }
+    throw new InferenceOutputError("Failed to fetch result from black forest labs API");
+  }
 };
 
 // src/providers/cerebras.ts
-var CEREBRAS_API_BASE_URL = "https://api.cerebras.ai";
-var makeBaseUrl2 = () => {
-  return CEREBRAS_API_BASE_URL;
-};
-var makeBody2 = (params) => {
-  return {
-    ...params.args,
-    model: params.model
-  };
-};
-var makeHeaders2 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
-};
-var makeUrl2 = (params) => {
-  return `${params.baseUrl}/v1/chat/completions`;
-};
-var CEREBRAS_CONFIG = {
-  makeBaseUrl: makeBaseUrl2,
-  makeBody: makeBody2,
-  makeHeaders: makeHeaders2,
-  makeUrl: makeUrl2
+var CerebrasConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("cerebras", "https://api.cerebras.ai");
+  }
 };
 
 // src/providers/cohere.ts
-var COHERE_API_BASE_URL = "https://api.cohere.com";
-var makeBaseUrl3 = () => {
-  return COHERE_API_BASE_URL;
-};
-var makeBody3 = (params) => {
-  return {
-    ...params.args,
-    model: params.model
-  };
-};
-var makeHeaders3 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
-};
-var makeUrl3 = (params) => {
-  return `${params.baseUrl}/compatibility/v1/chat/completions`;
-};
-var COHERE_CONFIG = {
-  makeBaseUrl: makeBaseUrl3,
-  makeBody: makeBody3,
-  makeHeaders: makeHeaders3,
-  makeUrl: makeUrl3
-};
-
-// src/lib/InferenceOutputError.ts
-var InferenceOutputError = class extends TypeError {
-  constructor(message) {
-    super(
-      `Invalid inference output: ${message}. Use the 'request' method with the same parameters to do a custom call with no type checking.`
-    );
-    this.name = "InferenceOutputError";
+var CohereConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("cohere", "https://api.cohere.com");
+  }
+  makeRoute() {
+    return "/compatibility/v1/chat/completions";
   }
 };
 
@@ -134,352 +254,902 @@ function isUrl(modelOrUrl) {
   return /^http(s?):/.test(modelOrUrl) || modelOrUrl.startsWith("/");
 }
 
-// src/utils/delay.ts
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(), ms);
-  });
-}
-
 // src/providers/fal-ai.ts
-var FAL_AI_API_BASE_URL = "https://fal.run";
-var FAL_AI_API_BASE_URL_QUEUE = "https://queue.fal.run";
-var makeBaseUrl4 = (task) => {
-  return task === "text-to-video" ? FAL_AI_API_BASE_URL_QUEUE : FAL_AI_API_BASE_URL;
+var FAL_AI_SUPPORTED_BLOB_TYPES = ["audio/mpeg", "audio/mp4", "audio/wav", "audio/x-wav"];
+var FalAITask = class extends TaskProviderHelper {
+  constructor(url) {
+    super("fal-ai", url || "https://fal.run");
+  }
+  preparePayload(params) {
+    return params.args;
+  }
+  makeRoute(params) {
+    return `/${params.model}`;
+  }
+  prepareHeaders(params, binary) {
+    const headers = {
+      Authorization: params.authMethod !== "provider-key" ? `Bearer ${params.accessToken}` : `Key ${params.accessToken}`
+    };
+    if (!binary) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
 };
-var makeBody4 = (params) => {
-  return params.args;
+function buildLoraPath(modelId, adapterWeightsPath) {
+  return `${HF_HUB_URL}/${modelId}/resolve/main/${adapterWeightsPath}`;
+}
+var FalAITextToImageTask = class extends FalAITask {
+  preparePayload(params) {
+    const payload = {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      sync_mode: true,
+      prompt: params.args.inputs,
+      ...params.mapping?.adapter === "lora" && params.mapping.adapterWeightsPath ? {
+        loras: [
+          {
+            path: buildLoraPath(params.mapping.hfModelId, params.mapping.adapterWeightsPath),
+            scale: 1
+          }
+        ]
+      } : void 0
+    };
+    if (params.mapping?.adapter === "lora" && params.mapping.adapterWeightsPath) {
+      payload.loras = [
+        {
+          path: buildLoraPath(params.mapping.hfModelId, params.mapping.adapterWeightsPath),
+          scale: 1
+        }
+      ];
+      if (params.mapping.providerId === "fal-ai/lora") {
+        payload.model_name = "stabilityai/stable-diffusion-xl-base-1.0";
+      }
+    }
+    return payload;
+  }
+  async getResponse(response, outputType) {
+    if (typeof response === "object" && "images" in response && Array.isArray(response.images) && response.images.length > 0 && "url" in response.images[0] && typeof response.images[0].url === "string") {
+      if (outputType === "url") {
+        return response.images[0].url;
+      }
+      const urlResponse = await fetch(response.images[0].url);
+      return await urlResponse.blob();
+    }
+    throw new InferenceOutputError("Expected Fal.ai text-to-image response format");
+  }
 };
-var makeHeaders4 = (params) => {
-  return {
-    Authorization: params.authMethod === "provider-key" ? `Key ${params.accessToken}` : `Bearer ${params.accessToken}`
-  };
+var FalAITextToVideoTask = class extends FalAITask {
+  constructor() {
+    super("https://queue.fal.run");
+  }
+  makeRoute(params) {
+    if (params.authMethod !== "provider-key") {
+      return `/${params.model}?_subdomain=queue`;
+    }
+    return `/${params.model}`;
+  }
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      prompt: params.args.inputs
+    };
+  }
+  async getResponse(response, url, headers) {
+    if (!url || !headers) {
+      throw new InferenceOutputError("URL and headers are required for text-to-video task");
+    }
+    const requestId = response.request_id;
+    if (!requestId) {
+      throw new InferenceOutputError("No request ID found in the response");
+    }
+    let status = response.status;
+    const parsedUrl = new URL(url);
+    const baseUrl = `${parsedUrl.protocol}//${parsedUrl.host}${parsedUrl.host === "router.huggingface.co" ? "/fal-ai" : ""}`;
+    const modelId = new URL(response.response_url).pathname;
+    const queryParams = parsedUrl.search;
+    const statusUrl = `${baseUrl}${modelId}/status${queryParams}`;
+    const resultUrl = `${baseUrl}${modelId}${queryParams}`;
+    while (status !== "COMPLETED") {
+      await delay(500);
+      const statusResponse = await fetch(statusUrl, { headers });
+      if (!statusResponse.ok) {
+        throw new InferenceOutputError("Failed to fetch response status from fal-ai API");
+      }
+      try {
+        status = (await statusResponse.json()).status;
+      } catch (error) {
+        throw new InferenceOutputError("Failed to parse status response from fal-ai API");
+      }
+    }
+    const resultResponse = await fetch(resultUrl, { headers });
+    let result;
+    try {
+      result = await resultResponse.json();
+    } catch (error) {
+      throw new InferenceOutputError("Failed to parse result response from fal-ai API");
+    }
+    if (typeof result === "object" && !!result && "video" in result && typeof result.video === "object" && !!result.video && "url" in result.video && typeof result.video.url === "string" && isUrl(result.video.url)) {
+      const urlResponse = await fetch(result.video.url);
+      return await urlResponse.blob();
+    } else {
+      throw new InferenceOutputError(
+        "Expected { video: { url: string } } result format, got instead: " + JSON.stringify(result)
+      );
+    }
+  }
+};
+var FalAIAutomaticSpeechRecognitionTask = class extends FalAITask {
+  prepareHeaders(params, binary) {
+    const headers = super.prepareHeaders(params, binary);
+    headers["Content-Type"] = "application/json";
+    return headers;
+  }
+  async getResponse(response) {
+    const res = response;
+    if (typeof res?.text !== "string") {
+      throw new InferenceOutputError(
+        `Expected { text: string } format from Fal.ai Automatic Speech Recognition, got: ${JSON.stringify(response)}`
+      );
+    }
+    return { text: res.text };
+  }
 };
-var makeUrl4 = (params) => {
-  const baseUrl = `${params.baseUrl}/${params.model}`;
-  if (params.authMethod !== "provider-key" && params.task === "text-to-video") {
-    return `${baseUrl}?_subdomain=queue`;
-  }
-  return baseUrl;
-};
-var FAL_AI_CONFIG = {
-  makeBaseUrl: makeBaseUrl4,
-  makeBody: makeBody4,
-  makeHeaders: makeHeaders4,
-  makeUrl: makeUrl4
-};
-async function pollFalResponse(res, url, headers) {
-  const requestId = res.request_id;
-  if (!requestId) {
-    throw new InferenceOutputError("No request ID found in the response");
-  }
-  let status = res.status;
-  const parsedUrl = new URL(url);
-  const baseUrl = `${parsedUrl.protocol}//${parsedUrl.host}${parsedUrl.host === "router.huggingface.co" ? "/fal-ai" : ""}`;
-  const modelId = new URL(res.response_url).pathname;
-  const queryParams = parsedUrl.search;
-  const statusUrl = `${baseUrl}${modelId}/status${queryParams}`;
-  const resultUrl = `${baseUrl}${modelId}${queryParams}`;
-  while (status !== "COMPLETED") {
-    await delay(500);
-    const statusResponse = await fetch(statusUrl, { headers });
-    if (!statusResponse.ok) {
-      throw new InferenceOutputError("Failed to fetch response status from fal-ai API");
+var FalAITextToSpeechTask = class extends FalAITask {
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      lyrics: params.args.inputs
+    };
+  }
+  async getResponse(response) {
+    const res = response;
+    if (typeof res?.audio?.url !== "string") {
+      throw new InferenceOutputError(
+        `Expected { audio: { url: string } } format from Fal.ai Text-to-Speech, got: ${JSON.stringify(response)}`
+      );
     }
     try {
-      status = (await statusResponse.json()).status;
+      const urlResponse = await fetch(res.audio.url);
+      if (!urlResponse.ok) {
+        throw new Error(`Failed to fetch audio from ${res.audio.url}: ${urlResponse.statusText}`);
+      }
+      return await urlResponse.blob();
     } catch (error) {
-      throw new InferenceOutputError("Failed to parse status response from fal-ai API");
+      throw new InferenceOutputError(
+        `Error fetching or processing audio from Fal.ai Text-to-Speech URL: ${res.audio.url}. ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
-  const resultResponse = await fetch(resultUrl, { headers });
-  let result;
-  try {
-    result = await resultResponse.json();
-  } catch (error) {
-    throw new InferenceOutputError("Failed to parse result response from fal-ai API");
+};
+
+// src/providers/fireworks-ai.ts
+var FireworksConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("fireworks-ai", "https://api.fireworks.ai");
   }
-  if (typeof result === "object" && !!result && "video" in result && typeof result.video === "object" && !!result.video && "url" in result.video && typeof result.video.url === "string" && isUrl(result.video.url)) {
-    const urlResponse = await fetch(result.video.url);
-    return await urlResponse.blob();
-  } else {
+  makeRoute() {
+    return "/inference/v1/chat/completions";
+  }
+};
+
+// src/providers/hf-inference.ts
+var EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS = ["feature-extraction", "sentence-similarity"];
+var HFInferenceTask = class extends TaskProviderHelper {
+  constructor() {
+    super("hf-inference", `${HF_ROUTER_URL}/hf-inference`);
+  }
+  preparePayload(params) {
+    return params.args;
+  }
+  makeUrl(params) {
+    if (params.model.startsWith("http://") || params.model.startsWith("https://")) {
+      return params.model;
+    }
+    return super.makeUrl(params);
+  }
+  makeRoute(params) {
+    if (params.task && ["feature-extraction", "sentence-similarity"].includes(params.task)) {
+      return `pipeline/${params.task}/${params.model}`;
+    }
+    return `models/${params.model}`;
+  }
+  async getResponse(response) {
+    return response;
+  }
+};
+var HFInferenceTextToImageTask = class extends HFInferenceTask {
+  async getResponse(response, url, headers, outputType) {
+    if (!response) {
+      throw new InferenceOutputError("response is undefined");
+    }
+    if (typeof response == "object") {
+      if ("data" in response && Array.isArray(response.data) && response.data[0].b64_json) {
+        const base64Data = response.data[0].b64_json;
+        if (outputType === "url") {
+          return `data:image/jpeg;base64,${base64Data}`;
+        }
+        const base64Response = await fetch(`data:image/jpeg;base64,${base64Data}`);
+        return await base64Response.blob();
+      }
+      if ("output" in response && Array.isArray(response.output)) {
+        if (outputType === "url") {
+          return response.output[0];
+        }
+        const urlResponse = await fetch(response.output[0]);
+        const blob = await urlResponse.blob();
+        return blob;
+      }
+    }
+    if (response instanceof Blob) {
+      if (outputType === "url") {
+        const b64 = await response.arrayBuffer().then((buf) => Buffer.from(buf).toString("base64"));
+        return `data:image/jpeg;base64,${b64}`;
+      }
+      return response;
+    }
+    throw new InferenceOutputError("Expected a Blob ");
+  }
+};
+var HFInferenceConversationalTask = class extends HFInferenceTask {
+  makeUrl(params) {
+    let url;
+    if (params.model.startsWith("http://") || params.model.startsWith("https://")) {
+      url = params.model.trim();
+    } else {
+      url = `${this.makeBaseUrl(params)}/models/${params.model}`;
+    }
+    url = url.replace(/\/+$/, "");
+    if (url.endsWith("/v1")) {
+      url += "/chat/completions";
+    } else if (!url.endsWith("/chat/completions")) {
+      url += "/v1/chat/completions";
+    }
+    return url;
+  }
+  preparePayload(params) {
+    return {
+      ...params.args,
+      model: params.model
+    };
+  }
+  async getResponse(response) {
+    return response;
+  }
+};
+var HFInferenceTextGenerationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    const res = toArray(response);
+    if (Array.isArray(res) && res.every((x) => "generated_text" in x && typeof x?.generated_text === "string")) {
+      return res?.[0];
+    }
+    throw new InferenceOutputError("Expected Array<{generated_text: string}>");
+  }
+};
+var HFInferenceAudioClassificationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every(
+      (x) => typeof x === "object" && x !== null && typeof x.label === "string" && typeof x.score === "number"
+    )) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}> but received different format");
+  }
+};
+var HFInferenceAutomaticSpeechRecognitionTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    return response;
+  }
+};
+var HFInferenceAudioToAudioTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (!Array.isArray(response)) {
+      throw new InferenceOutputError("Expected Array");
+    }
+    if (!response.every((elem) => {
+      return typeof elem === "object" && elem && "label" in elem && typeof elem.label === "string" && "content-type" in elem && typeof elem["content-type"] === "string" && "blob" in elem && typeof elem.blob === "string";
+    })) {
+      throw new InferenceOutputError("Expected Array<{label: string, audio: Blob}>");
+    }
+    return response;
+  }
+};
+var HFInferenceDocumentQuestionAnsweringTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every(
+      (elem) => typeof elem === "object" && !!elem && typeof elem?.answer === "string" && (typeof elem.end === "number" || typeof elem.end === "undefined") && (typeof elem.score === "number" || typeof elem.score === "undefined") && (typeof elem.start === "number" || typeof elem.start === "undefined")
+    )) {
+      return response[0];
+    }
+    throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
+  }
+};
+var HFInferenceFeatureExtractionTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    const isNumArrayRec = (arr, maxDepth, curDepth = 0) => {
+      if (curDepth > maxDepth)
+        return false;
+      if (arr.every((x) => Array.isArray(x))) {
+        return arr.every((x) => isNumArrayRec(x, maxDepth, curDepth + 1));
+      } else {
+        return arr.every((x) => typeof x === "number");
+      }
+    };
+    if (Array.isArray(response) && isNumArrayRec(response, 3, 0)) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<number[][][] | number[][] | number[] | number>");
+  }
+};
+var HFInferenceImageClassificationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x.label === "string" && typeof x.score === "number")) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
+  }
+};
+var HFInferenceImageSegmentationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x.label === "string" && typeof x.mask === "string" && typeof x.score === "number")) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<{label: string, mask: string, score: number}>");
+  }
+};
+var HFInferenceImageToTextTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (typeof response?.generated_text !== "string") {
+      throw new InferenceOutputError("Expected {generated_text: string}");
+    }
+    return response;
+  }
+};
+var HFInferenceImageToImageTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (response instanceof Blob) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Blob");
+  }
+};
+var HFInferenceObjectDetectionTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every(
+      (x) => typeof x.label === "string" && typeof x.score === "number" && typeof x.box.xmin === "number" && typeof x.box.ymin === "number" && typeof x.box.xmax === "number" && typeof x.box.ymax === "number"
+    )) {
+      return response;
+    }
     throw new InferenceOutputError(
-      "Expected { video: { url: string } } result format, got instead: " + JSON.stringify(result)
+      "Expected Array<{label: string, score: number, box: {xmin: number, ymin: number, xmax: number, ymax: number}}>"
     );
   }
-}
-
-// src/providers/fireworks-ai.ts
-var FIREWORKS_AI_API_BASE_URL = "https://api.fireworks.ai";
-var makeBaseUrl5 = () => {
-  return FIREWORKS_AI_API_BASE_URL;
 };
-var makeBody5 = (params) => {
-  return {
-    ...params.args,
-    ...params.chatCompletion ? { model: params.model } : void 0
-  };
+var HFInferenceZeroShotImageClassificationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x.label === "string" && typeof x.score === "number")) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
+  }
 };
-var makeHeaders5 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
+var HFInferenceTextClassificationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    const output = response?.[0];
+    if (Array.isArray(output) && output.every((x) => typeof x?.label === "string" && typeof x.score === "number")) {
+      return output;
+    }
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
+  }
 };
-var makeUrl5 = (params) => {
-  if (params.chatCompletion) {
-    return `${params.baseUrl}/inference/v1/chat/completions`;
+var HFInferenceQuestionAnsweringTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) ? response.every(
+      (elem) => typeof elem === "object" && !!elem && typeof elem.answer === "string" && typeof elem.end === "number" && typeof elem.score === "number" && typeof elem.start === "number"
+    ) : typeof response === "object" && !!response && typeof response.answer === "string" && typeof response.end === "number" && typeof response.score === "number" && typeof response.start === "number") {
+      return Array.isArray(response) ? response[0] : response;
+    }
+    throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
   }
-  return `${params.baseUrl}/inference`;
 };
-var FIREWORKS_AI_CONFIG = {
-  makeBaseUrl: makeBaseUrl5,
-  makeBody: makeBody5,
-  makeHeaders: makeHeaders5,
-  makeUrl: makeUrl5
+var HFInferenceFillMaskTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every(
+      (x) => typeof x.score === "number" && typeof x.sequence === "string" && typeof x.token === "number" && typeof x.token_str === "string"
+    )) {
+      return response;
+    }
+    throw new InferenceOutputError(
+      "Expected Array<{score: number, sequence: string, token: number, token_str: string}>"
+    );
+  }
 };
-
-// src/providers/hf-inference.ts
-var makeBaseUrl6 = () => {
-  return `${HF_ROUTER_URL}/hf-inference`;
+var HFInferenceZeroShotClassificationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every(
+      (x) => Array.isArray(x.labels) && x.labels.every((_label) => typeof _label === "string") && Array.isArray(x.scores) && x.scores.every((_score) => typeof _score === "number") && typeof x.sequence === "string"
+    )) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<{labels: string[], scores: number[], sequence: string}>");
+  }
 };
-var makeBody6 = (params) => {
-  return {
-    ...params.args,
-    ...params.chatCompletion ? { model: params.model } : void 0
-  };
+var HFInferenceSentenceSimilarityTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x === "number")) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<number>");
+  }
 };
-var makeHeaders6 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
+var HFInferenceTableQuestionAnsweringTask = class extends HFInferenceTask {
+  static validate(elem) {
+    return typeof elem === "object" && !!elem && "aggregator" in elem && typeof elem.aggregator === "string" && "answer" in elem && typeof elem.answer === "string" && "cells" in elem && Array.isArray(elem.cells) && elem.cells.every((x) => typeof x === "string") && "coordinates" in elem && Array.isArray(elem.coordinates) && elem.coordinates.every(
+      (coord) => Array.isArray(coord) && coord.every((x) => typeof x === "number")
+    );
+  }
+  async getResponse(response) {
+    if (Array.isArray(response) && Array.isArray(response) ? response.every((elem) => HFInferenceTableQuestionAnsweringTask.validate(elem)) : HFInferenceTableQuestionAnsweringTask.validate(response)) {
+      return Array.isArray(response) ? response[0] : response;
+    }
+    throw new InferenceOutputError(
+      "Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}"
+    );
+  }
 };
-var makeUrl6 = (params) => {
-  if (params.task && ["feature-extraction", "sentence-similarity"].includes(params.task)) {
-    return `${params.baseUrl}/pipeline/${params.task}/${params.model}`;
+var HFInferenceTokenClassificationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every(
+      (x) => typeof x.end === "number" && typeof x.entity_group === "string" && typeof x.score === "number" && typeof x.start === "number" && typeof x.word === "string"
+    )) {
+      return response;
+    }
+    throw new InferenceOutputError(
+      "Expected Array<{end: number, entity_group: string, score: number, start: number, word: string}>"
+    );
   }
-  if (params.chatCompletion) {
-    return `${params.baseUrl}/models/${params.model}/v1/chat/completions`;
+};
+var HFInferenceTranslationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x?.translation_text === "string")) {
+      return response?.length === 1 ? response?.[0] : response;
+    }
+    throw new InferenceOutputError("Expected Array<{translation_text: string}>");
+  }
+};
+var HFInferenceSummarizationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x?.summary_text === "string")) {
+      return response?.[0];
+    }
+    throw new InferenceOutputError("Expected Array<{summary_text: string}>");
+  }
+};
+var HFInferenceTextToSpeechTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    return response;
   }
-  return `${params.baseUrl}/models/${params.model}`;
 };
-var HF_INFERENCE_CONFIG = {
-  makeBaseUrl: makeBaseUrl6,
-  makeBody: makeBody6,
-  makeHeaders: makeHeaders6,
-  makeUrl: makeUrl6
+var HFInferenceTabularClassificationTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x === "number")) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<number>");
+  }
+};
+var HFInferenceVisualQuestionAnsweringTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every(
+      (elem) => typeof elem === "object" && !!elem && typeof elem?.answer === "string" && typeof elem.score === "number"
+    )) {
+      return response[0];
+    }
+    throw new InferenceOutputError("Expected Array<{answer: string, score: number}>");
+  }
+};
+var HFInferenceTabularRegressionTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (Array.isArray(response) && response.every((x) => typeof x === "number")) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Array<number>");
+  }
+};
+var HFInferenceTextToAudioTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    return response;
+  }
 };
 
 // src/providers/hyperbolic.ts
 var HYPERBOLIC_API_BASE_URL = "https://api.hyperbolic.xyz";
-var makeBaseUrl7 = () => {
-  return HYPERBOLIC_API_BASE_URL;
-};
-var makeBody7 = (params) => {
-  return {
-    ...params.args,
-    ...params.task === "text-to-image" ? { model_name: params.model } : { model: params.model }
-  };
-};
-var makeHeaders7 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
+var HyperbolicConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("hyperbolic", HYPERBOLIC_API_BASE_URL);
+  }
 };
-var makeUrl7 = (params) => {
-  if (params.task === "text-to-image") {
-    return `${params.baseUrl}/v1/images/generations`;
+var HyperbolicTextGenerationTask = class extends BaseTextGenerationTask {
+  constructor() {
+    super("hyperbolic", HYPERBOLIC_API_BASE_URL);
+  }
+  makeRoute() {
+    return "v1/chat/completions";
+  }
+  preparePayload(params) {
+    return {
+      messages: [{ content: params.args.inputs, role: "user" }],
+      ...params.args.parameters ? {
+        max_tokens: params.args.parameters.max_new_tokens,
+        ...omit(params.args.parameters, "max_new_tokens")
+      } : void 0,
+      ...omit(params.args, ["inputs", "parameters"]),
+      model: params.model
+    };
+  }
+  async getResponse(response) {
+    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");
   }
-  return `${params.baseUrl}/v1/chat/completions`;
 };
-var HYPERBOLIC_CONFIG = {
-  makeBaseUrl: makeBaseUrl7,
-  makeBody: makeBody7,
-  makeHeaders: makeHeaders7,
-  makeUrl: makeUrl7
+var HyperbolicTextToImageTask = class extends TaskProviderHelper {
+  constructor() {
+    super("hyperbolic", HYPERBOLIC_API_BASE_URL);
+  }
+  makeRoute(params) {
+    return `/v1/images/generations`;
+  }
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      prompt: params.args.inputs,
+      model_name: params.model
+    };
+  }
+  async getResponse(response, url, headers, outputType) {
+    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");
+  }
 };
 
 // src/providers/nebius.ts
 var NEBIUS_API_BASE_URL = "https://api.studio.nebius.ai";
-var makeBaseUrl8 = () => {
-  return NEBIUS_API_BASE_URL;
-};
-var makeBody8 = (params) => {
-  return {
-    ...params.args,
-    model: params.model
-  };
+var NebiusConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("nebius", NEBIUS_API_BASE_URL);
+  }
 };
-var makeHeaders8 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
+var NebiusTextGenerationTask = class extends BaseTextGenerationTask {
+  constructor() {
+    super("nebius", NEBIUS_API_BASE_URL);
+  }
 };
-var makeUrl8 = (params) => {
-  if (params.task === "text-to-image") {
-    return `${params.baseUrl}/v1/images/generations`;
+var NebiusTextToImageTask = class extends TaskProviderHelper {
+  constructor() {
+    super("nebius", NEBIUS_API_BASE_URL);
   }
-  if (params.chatCompletion) {
-    return `${params.baseUrl}/v1/chat/completions`;
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      response_format: "b64_json",
+      prompt: params.args.inputs,
+      model: params.model
+    };
   }
-  if (params.task === "text-generation") {
-    return `${params.baseUrl}/v1/completions`;
+  makeRoute(params) {
+    return "v1/images/generations";
+  }
+  async getResponse(response, url, headers, outputType) {
+    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;
-};
-var NEBIUS_CONFIG = {
-  makeBaseUrl: makeBaseUrl8,
-  makeBody: makeBody8,
-  makeHeaders: makeHeaders8,
-  makeUrl: makeUrl8
 };
 
 // src/providers/novita.ts
 var NOVITA_API_BASE_URL = "https://api.novita.ai";
-var makeBaseUrl9 = () => {
-  return NOVITA_API_BASE_URL;
-};
-var makeBody9 = (params) => {
-  return {
-    ...params.args,
-    ...params.chatCompletion ? { model: params.model } : void 0
-  };
-};
-var makeHeaders9 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
+var NovitaTextGenerationTask = class extends BaseTextGenerationTask {
+  constructor() {
+    super("novita", NOVITA_API_BASE_URL);
+  }
+  makeRoute() {
+    return "/v3/openai/chat/completions";
+  }
 };
-var makeUrl9 = (params) => {
-  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}`;
+var NovitaConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("novita", NOVITA_API_BASE_URL);
+  }
+  makeRoute() {
+    return "/v3/openai/chat/completions";
   }
-  return params.baseUrl;
 };
-var NOVITA_CONFIG = {
-  makeBaseUrl: makeBaseUrl9,
-  makeBody: makeBody9,
-  makeHeaders: makeHeaders9,
-  makeUrl: makeUrl9
+
+// src/providers/openai.ts
+var OPENAI_API_BASE_URL = "https://api.openai.com";
+var OpenAIConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("openai", OPENAI_API_BASE_URL, true);
+  }
 };
 
 // src/providers/replicate.ts
-var REPLICATE_API_BASE_URL = "https://api.replicate.com";
-var makeBaseUrl10 = () => {
-  return REPLICATE_API_BASE_URL;
-};
-var makeBody10 = (params) => {
-  return {
-    input: params.args,
-    version: params.model.includes(":") ? params.model.split(":")[1] : void 0
-  };
+var ReplicateTask = class extends TaskProviderHelper {
+  constructor(url) {
+    super("replicate", url || "https://api.replicate.com");
+  }
+  makeRoute(params) {
+    if (params.model.includes(":")) {
+      return "v1/predictions";
+    }
+    return `v1/models/${params.model}/predictions`;
+  }
+  preparePayload(params) {
+    return {
+      input: {
+        ...omit(params.args, ["inputs", "parameters"]),
+        ...params.args.parameters,
+        prompt: params.args.inputs
+      },
+      version: params.model.includes(":") ? params.model.split(":")[1] : void 0
+    };
+  }
+  prepareHeaders(params, binary) {
+    const headers = { Authorization: `Bearer ${params.accessToken}`, Prefer: "wait" };
+    if (!binary) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  makeUrl(params) {
+    const baseUrl = this.makeBaseUrl(params);
+    if (params.model.includes(":")) {
+      return `${baseUrl}/v1/predictions`;
+    }
+    return `${baseUrl}/v1/models/${params.model}/predictions`;
+  }
 };
-var makeHeaders10 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}`, Prefer: "wait" };
+var ReplicateTextToImageTask = class extends ReplicateTask {
+  async getResponse(res, url, headers, outputType) {
+    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");
+  }
 };
-var makeUrl10 = (params) => {
-  if (params.model.includes(":")) {
-    return `${params.baseUrl}/v1/predictions`;
+var ReplicateTextToSpeechTask = class extends ReplicateTask {
+  preparePayload(params) {
+    const payload = super.preparePayload(params);
+    const input = payload["input"];
+    if (typeof input === "object" && input !== null && "prompt" in input) {
+      const inputObj = input;
+      inputObj["text"] = inputObj["prompt"];
+      delete inputObj["prompt"];
+    }
+    return payload;
+  }
+  async getResponse(response) {
+    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");
   }
-  return `${params.baseUrl}/v1/models/${params.model}/predictions`;
 };
-var REPLICATE_CONFIG = {
-  makeBaseUrl: makeBaseUrl10,
-  makeBody: makeBody10,
-  makeHeaders: makeHeaders10,
-  makeUrl: makeUrl10
+var ReplicateTextToVideoTask = class extends ReplicateTask {
+  async getResponse(response) {
+    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 }");
+  }
 };
 
 // src/providers/sambanova.ts
-var SAMBANOVA_API_BASE_URL = "https://api.sambanova.ai";
-var makeBaseUrl11 = () => {
-  return SAMBANOVA_API_BASE_URL;
-};
-var makeBody11 = (params) => {
-  return {
-    ...params.args,
-    ...params.chatCompletion ? { model: params.model } : void 0
-  };
-};
-var makeHeaders11 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
-};
-var makeUrl11 = (params) => {
-  if (params.chatCompletion) {
-    return `${params.baseUrl}/v1/chat/completions`;
+var SambanovaConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("sambanova", "https://api.sambanova.ai");
   }
-  return params.baseUrl;
-};
-var SAMBANOVA_CONFIG = {
-  makeBaseUrl: makeBaseUrl11,
-  makeBody: makeBody11,
-  makeHeaders: makeHeaders11,
-  makeUrl: makeUrl11
 };
 
 // src/providers/together.ts
 var TOGETHER_API_BASE_URL = "https://api.together.xyz";
-var makeBaseUrl12 = () => {
-  return TOGETHER_API_BASE_URL;
-};
-var makeBody12 = (params) => {
-  return {
-    ...params.args,
-    model: params.model
-  };
-};
-var makeHeaders12 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
+var TogetherConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("together", TOGETHER_API_BASE_URL);
+  }
 };
-var makeUrl12 = (params) => {
-  if (params.task === "text-to-image") {
-    return `${params.baseUrl}/v1/images/generations`;
+var TogetherTextGenerationTask = class extends BaseTextGenerationTask {
+  constructor() {
+    super("together", TOGETHER_API_BASE_URL);
   }
-  if (params.chatCompletion) {
-    return `${params.baseUrl}/v1/chat/completions`;
+  preparePayload(params) {
+    return {
+      model: params.model,
+      ...params.args,
+      prompt: params.args.inputs
+    };
   }
-  if (params.task === "text-generation") {
-    return `${params.baseUrl}/v1/completions`;
+  async getResponse(response) {
+    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");
   }
-  return params.baseUrl;
 };
-var TOGETHER_CONFIG = {
-  makeBaseUrl: makeBaseUrl12,
-  makeBody: makeBody12,
-  makeHeaders: makeHeaders12,
-  makeUrl: makeUrl12
+var TogetherTextToImageTask = class extends TaskProviderHelper {
+  constructor() {
+    super("together", TOGETHER_API_BASE_URL);
+  }
+  makeRoute() {
+    return "v1/images/generations";
+  }
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      prompt: params.args.inputs,
+      response_format: "base64",
+      model: params.model
+    };
+  }
+  async getResponse(response, outputType) {
+    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");
+  }
 };
 
-// src/providers/openai.ts
-var OPENAI_API_BASE_URL = "https://api.openai.com";
-var makeBaseUrl13 = () => {
-  return OPENAI_API_BASE_URL;
-};
-var makeBody13 = (params) => {
-  if (!params.chatCompletion) {
-    throw new Error("OpenAI only supports chat completions.");
+// src/lib/getProviderHelper.ts
+var PROVIDERS = {
+  "black-forest-labs": {
+    "text-to-image": new BlackForestLabsTextToImageTask()
+  },
+  cerebras: {
+    conversational: new CerebrasConversationalTask()
+  },
+  cohere: {
+    conversational: new CohereConversationalTask()
+  },
+  "fal-ai": {
+    "text-to-image": new FalAITextToImageTask(),
+    "text-to-speech": new FalAITextToSpeechTask(),
+    "text-to-video": new FalAITextToVideoTask(),
+    "automatic-speech-recognition": new FalAIAutomaticSpeechRecognitionTask()
+  },
+  "hf-inference": {
+    "text-to-image": new HFInferenceTextToImageTask(),
+    conversational: new HFInferenceConversationalTask(),
+    "text-generation": new HFInferenceTextGenerationTask(),
+    "text-classification": new HFInferenceTextClassificationTask(),
+    "question-answering": new HFInferenceQuestionAnsweringTask(),
+    "audio-classification": new HFInferenceAudioClassificationTask(),
+    "automatic-speech-recognition": new HFInferenceAutomaticSpeechRecognitionTask(),
+    "fill-mask": new HFInferenceFillMaskTask(),
+    "feature-extraction": new HFInferenceFeatureExtractionTask(),
+    "image-classification": new HFInferenceImageClassificationTask(),
+    "image-segmentation": new HFInferenceImageSegmentationTask(),
+    "document-question-answering": new HFInferenceDocumentQuestionAnsweringTask(),
+    "image-to-text": new HFInferenceImageToTextTask(),
+    "object-detection": new HFInferenceObjectDetectionTask(),
+    "audio-to-audio": new HFInferenceAudioToAudioTask(),
+    "zero-shot-image-classification": new HFInferenceZeroShotImageClassificationTask(),
+    "zero-shot-classification": new HFInferenceZeroShotClassificationTask(),
+    "image-to-image": new HFInferenceImageToImageTask(),
+    "sentence-similarity": new HFInferenceSentenceSimilarityTask(),
+    "table-question-answering": new HFInferenceTableQuestionAnsweringTask(),
+    "tabular-classification": new HFInferenceTabularClassificationTask(),
+    "text-to-speech": new HFInferenceTextToSpeechTask(),
+    "token-classification": new HFInferenceTokenClassificationTask(),
+    translation: new HFInferenceTranslationTask(),
+    summarization: new HFInferenceSummarizationTask(),
+    "visual-question-answering": new HFInferenceVisualQuestionAnsweringTask(),
+    "tabular-regression": new HFInferenceTabularRegressionTask(),
+    "text-to-audio": new HFInferenceTextToAudioTask()
+  },
+  "fireworks-ai": {
+    conversational: new FireworksConversationalTask()
+  },
+  hyperbolic: {
+    "text-to-image": new HyperbolicTextToImageTask(),
+    conversational: new HyperbolicConversationalTask(),
+    "text-generation": new HyperbolicTextGenerationTask()
+  },
+  nebius: {
+    "text-to-image": new NebiusTextToImageTask(),
+    conversational: new NebiusConversationalTask(),
+    "text-generation": new NebiusTextGenerationTask()
+  },
+  novita: {
+    conversational: new NovitaConversationalTask(),
+    "text-generation": new NovitaTextGenerationTask()
+  },
+  openai: {
+    conversational: new OpenAIConversationalTask()
+  },
+  replicate: {
+    "text-to-image": new ReplicateTextToImageTask(),
+    "text-to-speech": new ReplicateTextToSpeechTask(),
+    "text-to-video": new ReplicateTextToVideoTask()
+  },
+  sambanova: {
+    conversational: new SambanovaConversationalTask()
+  },
+  together: {
+    "text-to-image": new TogetherTextToImageTask(),
+    conversational: new TogetherConversationalTask(),
+    "text-generation": new TogetherTextGenerationTask()
   }
-  return {
-    ...params.args,
-    model: params.model
-  };
 };
-var makeHeaders13 = (params) => {
-  return { Authorization: `Bearer ${params.accessToken}` };
-};
-var makeUrl13 = (params) => {
-  if (!params.chatCompletion) {
-    throw new Error("OpenAI only supports chat completions.");
+function getProviderHelper(provider, task) {
+  if (provider === "hf-inference") {
+    if (!task) {
+      return new HFInferenceTask();
+    }
   }
-  return `${params.baseUrl}/v1/chat/completions`;
-};
-var OPENAI_CONFIG = {
-  makeBaseUrl: makeBaseUrl13,
-  makeBody: makeBody13,
-  makeHeaders: makeHeaders13,
-  makeUrl: makeUrl13,
-  clientSideRoutingOnly: true
-};
+  if (!task) {
+    throw new Error("you need to provide a task name when using an external provider, e.g. 'text-to-image'");
+  }
+  if (!(provider in PROVIDERS)) {
+    throw new Error(`Provider '${provider}' not supported. Available providers: ${Object.keys(PROVIDERS)}`);
+  }
+  const providerTasks = PROVIDERS[provider];
+  if (!providerTasks || !(task in providerTasks)) {
+    throw new Error(
+      `Task '${task}' not supported for provider '${provider}'. Available tasks: ${Object.keys(providerTasks ?? {})}`
+    );
+  }
+  return providerTasks[task];
+}
 
 // package.json
 var name = "@huggingface/inference";
-var version = "3.7.0";
+var version = "3.8.0";
 
 // src/providers/consts.ts
-var HARDCODED_MODEL_ID_MAPPING = {
+var HARDCODED_MODEL_INFERENCE_MAPPING = {
   /**
    * "HF model ID" => "Model ID on Inference Provider's side"
    *
@@ -501,106 +1171,127 @@ var HARDCODED_MODEL_ID_MAPPING = {
   together: {}
 };
 
-// src/lib/getProviderModelId.ts
+// src/lib/getInferenceProviderMapping.ts
 var inferenceProviderMappingCache = /* @__PURE__ */ new Map();
-async function getProviderModelId(params, args, options = {}) {
-  if (params.provider === "hf-inference") {
-    return params.model;
-  }
-  if (!options.task) {
-    throw new Error("task must be specified when using a third-party provider");
-  }
-  const task = options.task === "text-generation" && options.chatCompletion ? "conversational" : options.task;
-  if (HARDCODED_MODEL_ID_MAPPING[params.provider]?.[params.model]) {
-    return HARDCODED_MODEL_ID_MAPPING[params.provider][params.model];
+async function getInferenceProviderMapping(params, options) {
+  if (HARDCODED_MODEL_INFERENCE_MAPPING[params.provider][params.modelId]) {
+    return HARDCODED_MODEL_INFERENCE_MAPPING[params.provider][params.modelId];
   }
   let inferenceProviderMapping;
-  if (inferenceProviderMappingCache.has(params.model)) {
-    inferenceProviderMapping = inferenceProviderMappingCache.get(params.model);
+  if (inferenceProviderMappingCache.has(params.modelId)) {
+    inferenceProviderMapping = inferenceProviderMappingCache.get(params.modelId);
   } else {
-    inferenceProviderMapping = await (options?.fetch ?? fetch)(
-      `${HF_HUB_URL}/api/models/${params.model}?expand[]=inferenceProviderMapping`,
+    const resp = await (options?.fetch ?? fetch)(
+      `${HF_HUB_URL}/api/models/${params.modelId}?expand[]=inferenceProviderMapping`,
       {
-        headers: args.accessToken?.startsWith("hf_") ? { Authorization: `Bearer ${args.accessToken}` } : {}
+        headers: params.accessToken?.startsWith("hf_") ? { Authorization: `Bearer ${params.accessToken}` } : {}
       }
-    ).then((resp) => resp.json()).then((json) => json.inferenceProviderMapping).catch(() => null);
+    );
+    if (resp.status === 404) {
+      throw new Error(`Model ${params.modelId} does not exist`);
+    }
+    inferenceProviderMapping = await resp.json().then((json) => json.inferenceProviderMapping).catch(() => null);
   }
   if (!inferenceProviderMapping) {
-    throw new Error(`We have not been able to find inference provider information for model ${params.model}.`);
+    throw new Error(`We have not been able to find inference provider information for model ${params.modelId}.`);
   }
   const providerMapping = inferenceProviderMapping[params.provider];
   if (providerMapping) {
-    if (providerMapping.task !== task) {
+    const equivalentTasks = params.provider === "hf-inference" && typedInclude(EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS, params.task) ? EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS : [params.task];
+    if (!typedInclude(equivalentTasks, providerMapping.task)) {
       throw new Error(
-        `Model ${params.model} is not supported for task ${task} and provider ${params.provider}. Supported task: ${providerMapping.task}.`
+        `Model ${params.modelId} is not supported for task ${params.task} and provider ${params.provider}. Supported task: ${providerMapping.task}.`
       );
     }
     if (providerMapping.status === "staging") {
       console.warn(
-        `Model ${params.model} is in staging mode for provider ${params.provider}. Meant for test purposes only.`
+        `Model ${params.modelId} is in staging mode for provider ${params.provider}. Meant for test purposes only.`
       );
     }
-    return providerMapping.providerId;
+    if (providerMapping.adapter === "lora") {
+      const treeResp = await (options?.fetch ?? fetch)(`${HF_HUB_URL}/api/models/${params.modelId}/tree/main`);
+      if (!treeResp.ok) {
+        throw new Error(`Unable to fetch the model tree for ${params.modelId}.`);
+      }
+      const tree = await treeResp.json();
+      const adapterWeightsPath = tree.find(({ type, path }) => type === "file" && path.endsWith(".safetensors"))?.path;
+      if (!adapterWeightsPath) {
+        throw new Error(`No .safetensors file found in the model tree for ${params.modelId}.`);
+      }
+      return {
+        ...providerMapping,
+        hfModelId: params.modelId,
+        adapterWeightsPath
+      };
+    }
+    return { ...providerMapping, hfModelId: params.modelId };
   }
-  throw new Error(`Model ${params.model} is not supported provider ${params.provider}.`);
+  return null;
 }
 
 // src/lib/makeRequestOptions.ts
-var HF_HUB_INFERENCE_PROXY_TEMPLATE = `${HF_ROUTER_URL}/{{PROVIDER}}`;
 var tasks = null;
-var providerConfigs = {
-  "black-forest-labs": BLACK_FOREST_LABS_CONFIG,
-  cerebras: CEREBRAS_CONFIG,
-  cohere: COHERE_CONFIG,
-  "fal-ai": FAL_AI_CONFIG,
-  "fireworks-ai": FIREWORKS_AI_CONFIG,
-  "hf-inference": HF_INFERENCE_CONFIG,
-  hyperbolic: HYPERBOLIC_CONFIG,
-  openai: OPENAI_CONFIG,
-  nebius: NEBIUS_CONFIG,
-  novita: NOVITA_CONFIG,
-  replicate: REPLICATE_CONFIG,
-  sambanova: SAMBANOVA_CONFIG,
-  together: TOGETHER_CONFIG
-};
-async function makeRequestOptions(args, options) {
+async function makeRequestOptions(args, providerHelper, options) {
   const { provider: maybeProvider, model: maybeModel } = args;
   const provider = maybeProvider ?? "hf-inference";
-  const providerConfig = providerConfigs[provider];
-  const { task, chatCompletion: chatCompletion2 } = options ?? {};
+  const { task } = options ?? {};
   if (args.endpointUrl && provider !== "hf-inference") {
     throw new Error(`Cannot use endpointUrl with a third-party provider.`);
   }
   if (maybeModel && isUrl(maybeModel)) {
     throw new Error(`Model URLs are no longer supported. Use endpointUrl instead.`);
   }
+  if (args.endpointUrl) {
+    return makeRequestOptionsFromResolvedModel(
+      maybeModel ?? args.endpointUrl,
+      providerHelper,
+      args,
+      void 0,
+      options
+    );
+  }
   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}`);
-  }
-  if (providerConfig.clientSideRoutingOnly && !maybeModel) {
+  const hfModel = maybeModel ?? await loadDefaultModel(task);
+  if (providerHelper.clientSideRoutingOnly && !maybeModel) {
     throw new Error(`Provider ${provider} requires a model ID to be passed directly.`);
   }
-  const hfModel = maybeModel ?? await loadDefaultModel(task);
-  const resolvedModel = providerConfig.clientSideRoutingOnly ? (
+  const inferenceProviderMapping = providerHelper.clientSideRoutingOnly ? {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    removeProviderPrefix(maybeModel, provider)
-  ) : await getProviderModelId({ model: hfModel, provider }, args, {
-    task,
-    chatCompletion: chatCompletion2,
-    fetch: options?.fetch
-  });
-  return makeRequestOptionsFromResolvedModel(resolvedModel, args, options);
+    providerId: removeProviderPrefix(maybeModel, provider),
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    hfModelId: maybeModel,
+    status: "live",
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    task
+  } : await getInferenceProviderMapping(
+    {
+      modelId: hfModel,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      task,
+      provider,
+      accessToken: args.accessToken
+    },
+    { fetch: options?.fetch }
+  );
+  if (!inferenceProviderMapping) {
+    throw new Error(`We have not been able to find inference provider information for model ${hfModel}.`);
+  }
+  return makeRequestOptionsFromResolvedModel(
+    inferenceProviderMapping.providerId,
+    providerHelper,
+    args,
+    inferenceProviderMapping,
+    options
+  );
 }
-function makeRequestOptionsFromResolvedModel(resolvedModel, args, options) {
+function makeRequestOptionsFromResolvedModel(resolvedModel, providerHelper, args, mapping, options) {
   const { accessToken, endpointUrl, provider: maybeProvider, model, ...remainingArgs } = args;
   const provider = maybeProvider ?? "hf-inference";
-  const providerConfig = providerConfigs[provider];
-  const { includeCredentials, task, chatCompletion: chatCompletion2, signal, billTo } = options ?? {};
+  const { includeCredentials, task, signal, billTo } = options ?? {};
   const authMethod = (() => {
-    if (providerConfig.clientSideRoutingOnly) {
+    if (providerHelper.clientSideRoutingOnly) {
       if (accessToken && accessToken.startsWith("hf_")) {
         throw new Error(`Provider ${provider} is closed-source and does not support HF tokens.`);
       }
@@ -614,35 +1305,31 @@ function makeRequestOptionsFromResolvedModel(resolvedModel, args, options) {
     }
     return "none";
   })();
-  const url = endpointUrl ? chatCompletion2 ? endpointUrl + `/v1/chat/completions` : endpointUrl : providerConfig.makeUrl({
+  const modelId = endpointUrl ?? resolvedModel;
+  const url = providerHelper.makeUrl({
     authMethod,
-    baseUrl: authMethod !== "provider-key" ? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", provider) : providerConfig.makeBaseUrl(task),
-    model: resolvedModel,
-    chatCompletion: chatCompletion2,
+    model: modelId,
     task
   });
-  const binary = "data" in args && !!args.data;
-  const headers = providerConfig.makeHeaders({
-    accessToken,
-    authMethod
-  });
+  const headers = providerHelper.prepareHeaders(
+    {
+      accessToken,
+      authMethod
+    },
+    "data" in args && !!args.data
+  );
   if (billTo) {
     headers[HF_HEADER_X_BILL_TO] = billTo;
   }
-  if (!binary) {
-    headers["Content-Type"] = "application/json";
-  }
   const ownUserAgent = `${name}/${version}`;
   const userAgent = [ownUserAgent, typeof navigator !== "undefined" ? navigator.userAgent : void 0].filter((x) => x !== void 0).join(" ");
   headers["User-Agent"] = userAgent;
-  const body = binary ? args.data : JSON.stringify(
-    providerConfig.makeBody({
-      args: remainingArgs,
-      model: resolvedModel,
-      task,
-      chatCompletion: chatCompletion2
-    })
-  );
+  const body = providerHelper.makeBody({
+    args: remainingArgs,
+    model: resolvedModel,
+    task,
+    mapping
+  });
   let credentials;
   if (typeof includeCredentials === "string") {
     credentials = includeCredentials;
@@ -782,12 +1469,12 @@ function newMessage() {
 }
 
 // src/utils/request.ts
-async function innerRequest(args, options) {
-  const { url, info } = await makeRequestOptions(args, options);
+async function innerRequest(args, providerHelper, options) {
+  const { url, info } = await makeRequestOptions(args, providerHelper, options);
   const response = await (options?.fetch ?? fetch)(url, info);
   const requestContext = { url, info };
   if (options?.retry_on_error !== false && response.status === 503) {
-    return innerRequest(args, options);
+    return innerRequest(args, providerHelper, options);
   }
   if (!response.ok) {
     const contentType = response.headers.get("Content-Type");
@@ -814,11 +1501,11 @@ async function innerRequest(args, options) {
   const blob = await response.blob();
   return { data: blob, requestContext };
 }
-async function* innerStreamingRequest(args, options) {
-  const { url, info } = await makeRequestOptions({ ...args, stream: true }, options);
+async function* innerStreamingRequest(args, providerHelper, options) {
+  const { url, info } = await makeRequestOptions({ ...args, stream: true }, providerHelper, options);
   const response = await (options?.fetch ?? fetch)(url, info);
   if (options?.retry_on_error !== false && response.status === 503) {
-    return yield* innerStreamingRequest(args, options);
+    return yield* innerStreamingRequest(args, providerHelper, options);
   }
   if (!response.ok) {
     if (response.headers.get("Content-Type")?.startsWith("application/json")) {
@@ -892,7 +1579,8 @@ async function request(args, options) {
   console.warn(
     "The request method is deprecated and will be removed in a future version of huggingface.js. Use specific task functions instead."
   );
-  const result = await innerRequest(args, options);
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", options?.task);
+  const result = await innerRequest(args, providerHelper, options);
   return result.data;
 }
 
@@ -901,31 +1589,8 @@ async function* streamingRequest(args, options) {
   console.warn(
     "The streamingRequest method is deprecated and will be removed in a future version of huggingface.js. Use specific task functions instead."
   );
-  yield* innerStreamingRequest(args, options);
-}
-
-// src/utils/pick.ts
-function pick(o, props) {
-  return Object.assign(
-    {},
-    ...props.map((prop) => {
-      if (o[prop] !== void 0) {
-        return { [prop]: o[prop] };
-      }
-    })
-  );
-}
-
-// src/utils/typedInclude.ts
-function typedInclude(arr, v) {
-  return arr.includes(v);
-}
-
-// src/utils/omit.ts
-function omit(o, props) {
-  const propsArr = Array.isArray(props) ? props : [props];
-  const letsKeep = Object.keys(o).filter((prop) => !typedInclude(propsArr, prop));
-  return pick(o, letsKeep);
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", options?.task);
+  yield* innerStreamingRequest(args, providerHelper, options);
 }
 
 // src/tasks/audio/utils.ts
@@ -938,16 +1603,24 @@ function preparePayload(args) {
 
 // src/tasks/audio/audioClassification.ts
 async function audioClassification(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "audio-classification");
   const payload = preparePayload(args);
-  const { data: res } = await innerRequest(payload, {
+  const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
     task: "audio-classification"
   });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
-  }
-  return res;
+  return providerHelper.getResponse(res);
+}
+
+// src/tasks/audio/audioToAudio.ts
+async function audioToAudio(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "audio-to-audio");
+  const payload = preparePayload(args);
+  const { data: res } = await innerRequest(payload, providerHelper, {
+    ...options,
+    task: "audio-to-audio"
+  });
+  return providerHelper.getResponse(res);
 }
 
 // src/utils/base64FromBytes.ts
@@ -965,8 +1638,9 @@ function base64FromBytes(arr) {
 
 // src/tasks/audio/automaticSpeechRecognition.ts
 async function automaticSpeechRecognition(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "automatic-speech-recognition");
   const payload = await buildPayload(args);
-  const { data: res } = await innerRequest(payload, {
+  const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
     task: "automatic-speech-recognition"
   });
@@ -974,9 +1648,8 @@ async function automaticSpeechRecognition(args, options) {
   if (!isValidOutput) {
     throw new InferenceOutputError("Expected {text: string}");
   }
-  return res;
+  return providerHelper.getResponse(res);
 }
-var FAL_AI_SUPPORTED_BLOB_TYPES = ["audio/mpeg", "audio/mp4", "audio/wav", "audio/x-wav"];
 async function buildPayload(args) {
   if (args.provider === "fal-ai") {
     const blob = "data" in args && args.data instanceof Blob ? args.data : "inputs" in args ? args.inputs : void 0;
@@ -1005,215 +1678,45 @@ async function buildPayload(args) {
 
 // src/tasks/audio/textToSpeech.ts
 async function textToSpeech(args, options) {
-  const payload = args.provider === "replicate" ? {
-    ...omit(args, ["inputs", "parameters"]),
-    ...args.parameters,
-    text: args.inputs
-  } : args;
-  const { data: res } = await innerRequest(payload, {
+  const provider = args.provider ?? "hf-inference";
+  const providerHelper = getProviderHelper(provider, "text-to-speech");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "text-to-speech"
   });
-  if (res instanceof Blob) {
-    return res;
-  }
-  if (res && typeof res === "object") {
-    if ("output" in res) {
-      if (typeof res.output === "string") {
-        const urlResponse = await fetch(res.output);
-        const blob = await urlResponse.blob();
-        return blob;
-      } else if (Array.isArray(res.output)) {
-        const urlResponse = await fetch(res.output[0]);
-        const blob = await urlResponse.blob();
-        return blob;
-      }
-    }
-  }
-  throw new InferenceOutputError("Expected Blob or object with output");
-}
-
-// src/tasks/audio/audioToAudio.ts
-async function audioToAudio(args, options) {
-  const payload = preparePayload(args);
-  const { data: res } = await innerRequest(payload, {
-    ...options,
-    task: "audio-to-audio"
-  });
-  return validateOutput(res);
-}
-function validateOutput(output) {
-  if (!Array.isArray(output)) {
-    throw new InferenceOutputError("Expected Array");
-  }
-  if (!output.every((elem) => {
-    return typeof elem === "object" && elem && "label" in elem && typeof elem.label === "string" && "content-type" in elem && typeof elem["content-type"] === "string" && "blob" in elem && typeof elem.blob === "string";
-  })) {
-    throw new InferenceOutputError("Expected Array<{label: string, audio: Blob}>");
-  }
-  return output;
-}
-
-// src/tasks/cv/utils.ts
-function preparePayload2(args) {
-  return "data" in args ? args : { ...omit(args, "inputs"), data: args.inputs };
-}
-
-// src/tasks/cv/imageClassification.ts
-async function imageClassification(args, options) {
-  const payload = preparePayload2(args);
-  const { data: res } = await innerRequest(payload, {
-    ...options,
-    task: "image-classification"
-  });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
-  }
-  return res;
-}
-
-// src/tasks/cv/imageSegmentation.ts
-async function imageSegmentation(args, options) {
-  const payload = preparePayload2(args);
-  const { data: res } = await innerRequest(payload, {
-    ...options,
-    task: "image-segmentation"
-  });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.mask === "string" && typeof x.score === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{label: string, mask: string, score: number}>");
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
-
-// src/tasks/cv/imageToText.ts
-async function imageToText(args, options) {
-  const payload = preparePayload2(args);
-  const { data: res } = await innerRequest(payload, {
-    ...options,
-    task: "image-to-text"
-  });
-  if (typeof res?.[0]?.generated_text !== "string") {
-    throw new InferenceOutputError("Expected {generated_text: string}");
-  }
-  return res?.[0];
+
+// src/tasks/cv/utils.ts
+function preparePayload2(args) {
+  return "data" in args ? args : { ...omit(args, "inputs"), data: args.inputs };
 }
 
-// src/tasks/cv/objectDetection.ts
-async function objectDetection(args, options) {
+// src/tasks/cv/imageClassification.ts
+async function imageClassification(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-classification");
   const payload = preparePayload2(args);
-  const { data: res } = await innerRequest(payload, {
+  const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
-    task: "object-detection"
+    task: "image-classification"
   });
-  const isValidOutput = Array.isArray(res) && res.every(
-    (x) => typeof x.label === "string" && typeof x.score === "number" && typeof x.box.xmin === "number" && typeof x.box.ymin === "number" && typeof x.box.xmax === "number" && typeof x.box.ymax === "number"
-  );
-  if (!isValidOutput) {
-    throw new InferenceOutputError(
-      "Expected Array<{label:string; score:number; box:{xmin:number; ymin:number; xmax:number; ymax:number}}>"
-    );
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
 
-// src/tasks/cv/textToImage.ts
-function getResponseFormatArg(provider) {
-  switch (provider) {
-    case "fal-ai":
-      return { sync_mode: true };
-    case "nebius":
-      return { response_format: "b64_json" };
-    case "replicate":
-      return void 0;
-    case "together":
-      return { response_format: "base64" };
-    default:
-      return void 0;
-  }
-}
-async function textToImage(args, options) {
-  const payload = !args.provider || args.provider === "hf-inference" || args.provider === "sambanova" ? args : {
-    ...omit(args, ["inputs", "parameters"]),
-    ...args.parameters,
-    ...getResponseFormatArg(args.provider),
-    prompt: args.inputs
-  };
-  const { data: res } = await innerRequest(payload, {
+// src/tasks/cv/imageSegmentation.ts
+async function imageSegmentation(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-segmentation");
+  const payload = preparePayload2(args);
+  const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
-    task: "text-to-image"
+    task: "image-segmentation"
   });
-  if (res && typeof res === "object") {
-    if (args.provider === "black-forest-labs" && "polling_url" in res && typeof res.polling_url === "string") {
-      return await pollBflResponse(res.polling_url, options?.outputType);
-    }
-    if (args.provider === "fal-ai" && "images" in res && Array.isArray(res.images) && res.images[0].url) {
-      if (options?.outputType === "url") {
-        return res.images[0].url;
-      } else {
-        const image = await fetch(res.images[0].url);
-        return await image.blob();
-      }
-    }
-    if (args.provider === "hyperbolic" && "images" in res && Array.isArray(res.images) && res.images[0] && typeof res.images[0].image === "string") {
-      if (options?.outputType === "url") {
-        return `data:image/jpeg;base64,${res.images[0].image}`;
-      }
-      const base64Response = await fetch(`data:image/jpeg;base64,${res.images[0].image}`);
-      return await base64Response.blob();
-    }
-    if ("data" in res && Array.isArray(res.data) && res.data[0].b64_json) {
-      const base64Data = res.data[0].b64_json;
-      if (options?.outputType === "url") {
-        return `data:image/jpeg;base64,${base64Data}`;
-      }
-      const base64Response = await fetch(`data:image/jpeg;base64,${base64Data}`);
-      return await base64Response.blob();
-    }
-    if ("output" in res && Array.isArray(res.output)) {
-      if (options?.outputType === "url") {
-        return res.output[0];
-      }
-      const urlResponse = await fetch(res.output[0]);
-      const blob = await urlResponse.blob();
-      return blob;
-    }
-  }
-  const isValidOutput = res && res instanceof Blob;
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Blob");
-  }
-  if (options?.outputType === "url") {
-    const b64 = await res.arrayBuffer().then((buf) => Buffer.from(buf).toString("base64"));
-    return `data:image/jpeg;base64,${b64}`;
-  }
-  return res;
-}
-async function pollBflResponse(url, outputType) {
-  const urlObj = new URL(url);
-  for (let step = 0; step < 5; step++) {
-    await delay(1e3);
-    console.debug(`Polling Black Forest Labs API for the result... ${step + 1}/5`);
-    urlObj.searchParams.set("attempt", step.toString(10));
-    const resp = await fetch(urlObj, { headers: { "Content-Type": "application/json" } });
-    if (!resp.ok) {
-      throw new InferenceOutputError("Failed to fetch result from black forest labs API");
-    }
-    const payload = await resp.json();
-    if (typeof payload === "object" && payload && "status" in payload && typeof payload.status === "string" && payload.status === "Ready" && "result" in payload && typeof payload.result === "object" && payload.result && "sample" in payload.result && typeof payload.result.sample === "string") {
-      if (outputType === "url") {
-        return payload.result.sample;
-      }
-      const image = await fetch(payload.result.sample);
-      return await image.blob();
-    }
-  }
-  throw new InferenceOutputError("Failed to fetch result from black forest labs API");
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/cv/imageToImage.ts
 async function imageToImage(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-to-image");
   let reqArgs;
   if (!args.parameters) {
     reqArgs = {
@@ -1229,15 +1732,61 @@ async function imageToImage(args, options) {
       )
     };
   }
-  const { data: res } = await innerRequest(reqArgs, {
+  const { data: res } = await innerRequest(reqArgs, providerHelper, {
     ...options,
     task: "image-to-image"
   });
-  const isValidOutput = res && res instanceof Blob;
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Blob");
-  }
-  return res;
+  return providerHelper.getResponse(res);
+}
+
+// src/tasks/cv/imageToText.ts
+async function imageToText(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-to-text");
+  const payload = preparePayload2(args);
+  const { data: res } = await innerRequest(payload, providerHelper, {
+    ...options,
+    task: "image-to-text"
+  });
+  return providerHelper.getResponse(res[0]);
+}
+
+// src/tasks/cv/objectDetection.ts
+async function objectDetection(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "object-detection");
+  const payload = preparePayload2(args);
+  const { data: res } = await innerRequest(payload, providerHelper, {
+    ...options,
+    task: "object-detection"
+  });
+  return providerHelper.getResponse(res);
+}
+
+// src/tasks/cv/textToImage.ts
+async function textToImage(args, options) {
+  const provider = args.provider ?? "hf-inference";
+  const providerHelper = getProviderHelper(provider, "text-to-image");
+  const { data: res } = await innerRequest(args, providerHelper, {
+    ...options,
+    task: "text-to-image"
+  });
+  const { url, info } = await makeRequestOptions(args, providerHelper, { ...options, task: "text-to-image" });
+  return providerHelper.getResponse(res, url, info.headers, options?.outputType);
+}
+
+// src/tasks/cv/textToVideo.ts
+async function textToVideo(args, options) {
+  const provider = args.provider ?? "hf-inference";
+  const providerHelper = getProviderHelper(provider, "text-to-video");
+  const { data: response } = await innerRequest(
+    args,
+    providerHelper,
+    {
+      ...options,
+      task: "text-to-video"
+    }
+  );
+  const { url, info } = await makeRequestOptions(args, providerHelper, { ...options, task: "text-to-video" });
+  return providerHelper.getResponse(response, url, info.headers);
 }
 
 // src/tasks/cv/zeroShotImageClassification.ts
@@ -1263,231 +1812,126 @@ async function preparePayload3(args) {
   }
 }
 async function zeroShotImageClassification(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "zero-shot-image-classification");
   const payload = await preparePayload3(args);
-  const { data: res } = await innerRequest(payload, {
+  const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
     task: "zero-shot-image-classification"
   });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
 
-// src/tasks/cv/textToVideo.ts
-var SUPPORTED_PROVIDERS = ["fal-ai", "novita", "replicate"];
-async function textToVideo(args, options) {
-  if (!args.provider || !typedInclude(SUPPORTED_PROVIDERS, args.provider)) {
-    throw new Error(
-      `textToVideo inference is only supported for the following providers: ${SUPPORTED_PROVIDERS.join(", ")}`
-    );
-  }
-  const payload = args.provider === "fal-ai" || args.provider === "replicate" || args.provider === "novita" ? { ...omit(args, ["inputs", "parameters"]), ...args.parameters, prompt: args.inputs } : args;
-  const { data, requestContext } = await innerRequest(payload, {
+// src/tasks/nlp/chatCompletion.ts
+async function chatCompletion(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "conversational");
+  const { data: response } = await innerRequest(args, providerHelper, {
     ...options,
-    task: "text-to-video"
+    task: "conversational"
+  });
+  return providerHelper.getResponse(response);
+}
+
+// src/tasks/nlp/chatCompletionStream.ts
+async function* chatCompletionStream(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "conversational");
+  yield* innerStreamingRequest(args, providerHelper, {
+    ...options,
+    task: "conversational"
   });
-  if (args.provider === "fal-ai") {
-    return await pollFalResponse(
-      data,
-      requestContext.url,
-      requestContext.info.headers
-    );
-  } else if (args.provider === "novita") {
-    const isValidOutput = typeof data === "object" && !!data && "video" in data && typeof data.video === "object" && !!data.video && "video_url" in data.video && typeof data.video.video_url === "string" && isUrl(data.video.video_url);
-    if (!isValidOutput) {
-      throw new InferenceOutputError("Expected { video: { video_url: string } }");
-    }
-    const urlResponse = await fetch(data.video.video_url);
-    return await urlResponse.blob();
-  } else {
-    const isValidOutput = typeof data === "object" && !!data && "output" in data && typeof data.output === "string" && isUrl(data.output);
-    if (!isValidOutput) {
-      throw new InferenceOutputError("Expected { output: string }");
-    }
-    const urlResponse = await fetch(data.output);
-    return await urlResponse.blob();
-  }
 }
 
 // src/tasks/nlp/featureExtraction.ts
 async function featureExtraction(args, options) {
-  const { data: res } = await innerRequest(args, {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "feature-extraction");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "feature-extraction"
   });
-  let isValidOutput = true;
-  const isNumArrayRec = (arr, maxDepth, curDepth = 0) => {
-    if (curDepth > maxDepth)
-      return false;
-    if (arr.every((x) => Array.isArray(x))) {
-      return arr.every((x) => isNumArrayRec(x, maxDepth, curDepth + 1));
-    } else {
-      return arr.every((x) => typeof x === "number");
-    }
-  };
-  isValidOutput = Array.isArray(res) && isNumArrayRec(res, 3, 0);
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<number[][][] | number[][] | number[] | number>");
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/fillMask.ts
 async function fillMask(args, options) {
-  const { data: res } = await innerRequest(args, {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "fill-mask");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "fill-mask"
   });
-  const isValidOutput = Array.isArray(res) && res.every(
-    (x) => typeof x.score === "number" && typeof x.sequence === "string" && typeof x.token === "number" && typeof x.token_str === "string"
-  );
-  if (!isValidOutput) {
-    throw new InferenceOutputError(
-      "Expected Array<{score: number, sequence: string, token: number, token_str: string}>"
-    );
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/questionAnswering.ts
 async function questionAnswering(args, options) {
-  const { data: res } = await innerRequest(args, {
-    ...options,
-    task: "question-answering"
-  });
-  const isValidOutput = Array.isArray(res) ? res.every(
-    (elem) => typeof elem === "object" && !!elem && typeof elem.answer === "string" && typeof elem.end === "number" && typeof elem.score === "number" && typeof elem.start === "number"
-  ) : typeof res === "object" && !!res && typeof res.answer === "string" && typeof res.end === "number" && typeof res.score === "number" && typeof res.start === "number";
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
-  }
-  return Array.isArray(res) ? res[0] : res;
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "question-answering");
+  const { data: res } = await innerRequest(
+    args,
+    providerHelper,
+    {
+      ...options,
+      task: "question-answering"
+    }
+  );
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/sentenceSimilarity.ts
 async function sentenceSimilarity(args, options) {
-  const { data: res } = await innerRequest(args, {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "sentence-similarity");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "sentence-similarity"
   });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected number[]");
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/summarization.ts
 async function summarization(args, options) {
-  const { data: res } = await innerRequest(args, {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "summarization");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "summarization"
   });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.summary_text === "string");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{summary_text: string}>");
-  }
-  return res?.[0];
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/tableQuestionAnswering.ts
 async function tableQuestionAnswering(args, options) {
-  const { data: res } = await innerRequest(args, {
-    ...options,
-    task: "table-question-answering"
-  });
-  const isValidOutput = Array.isArray(res) ? res.every((elem) => validate(elem)) : validate(res);
-  if (!isValidOutput) {
-    throw new InferenceOutputError(
-      "Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}"
-    );
-  }
-  return Array.isArray(res) ? res[0] : res;
-}
-function validate(elem) {
-  return typeof elem === "object" && !!elem && "aggregator" in elem && typeof elem.aggregator === "string" && "answer" in elem && typeof elem.answer === "string" && "cells" in elem && Array.isArray(elem.cells) && elem.cells.every((x) => typeof x === "string") && "coordinates" in elem && Array.isArray(elem.coordinates) && elem.coordinates.every(
-    (coord) => Array.isArray(coord) && coord.every((x) => typeof x === "number")
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "table-question-answering");
+  const { data: res } = await innerRequest(
+    args,
+    providerHelper,
+    {
+      ...options,
+      task: "table-question-answering"
+    }
   );
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/textClassification.ts
 async function textClassification(args, options) {
-  const { data: res } = await innerRequest(args, {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-classification");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "text-classification"
   });
-  const output = res?.[0];
-  const isValidOutput = Array.isArray(output) && output.every((x) => typeof x?.label === "string" && typeof x.score === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
-  }
-  return output;
-}
-
-// src/utils/toArray.ts
-function toArray(obj) {
-  if (Array.isArray(obj)) {
-    return obj;
-  }
-  return [obj];
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/textGeneration.ts
 async function textGeneration(args, options) {
-  if (args.provider === "together") {
-    args.prompt = args.inputs;
-    const { data: raw } = await innerRequest(args, {
-      ...options,
-      task: "text-generation"
-    });
-    const isValidOutput = typeof raw === "object" && "choices" in raw && Array.isArray(raw?.choices) && typeof raw?.model === "string";
-    if (!isValidOutput) {
-      throw new InferenceOutputError("Expected ChatCompletionOutput");
-    }
-    const completion = raw.choices[0];
-    return {
-      generated_text: completion.text
-    };
-  } else if (args.provider === "hyperbolic") {
-    const payload = {
-      messages: [{ content: args.inputs, role: "user" }],
-      ...args.parameters ? {
-        max_tokens: args.parameters.max_new_tokens,
-        ...omit(args.parameters, "max_new_tokens")
-      } : void 0,
-      ...omit(args, ["inputs", "parameters"])
-    };
-    const raw = (await innerRequest(payload, {
-      ...options,
-      task: "text-generation"
-    })).data;
-    const isValidOutput = typeof raw === "object" && "choices" in raw && Array.isArray(raw?.choices) && typeof raw?.model === "string";
-    if (!isValidOutput) {
-      throw new InferenceOutputError("Expected ChatCompletionOutput");
-    }
-    const completion = raw.choices[0];
-    return {
-      generated_text: completion.message.content
-    };
-  } else {
-    const { data: res } = await innerRequest(args, {
-      ...options,
-      task: "text-generation"
-    });
-    const output = toArray(res);
-    const isValidOutput = Array.isArray(output) && output.every((x) => "generated_text" in x && typeof x?.generated_text === "string");
-    if (!isValidOutput) {
-      throw new InferenceOutputError("Expected Array<{generated_text: string}>");
-    }
-    return output?.[0];
-  }
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-generation");
+  const { data: response } = await innerRequest(args, providerHelper, {
+    ...options,
+    task: "text-generation"
+  });
+  return providerHelper.getResponse(response);
 }
 
 // src/tasks/nlp/textGenerationStream.ts
 async function* textGenerationStream(args, options) {
-  yield* innerStreamingRequest(args, {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-generation");
+  yield* innerStreamingRequest(args, providerHelper, {
     ...options,
     task: "text-generation"
   });
@@ -1495,77 +1939,45 @@ async function* textGenerationStream(args, options) {
 
 // src/tasks/nlp/tokenClassification.ts
 async function tokenClassification(args, options) {
-  const { data: res } = await innerRequest(args, {
-    ...options,
-    task: "token-classification"
-  });
-  const output = toArray(res);
-  const isValidOutput = Array.isArray(output) && output.every(
-    (x) => typeof x.end === "number" && typeof x.entity_group === "string" && typeof x.score === "number" && typeof x.start === "number" && typeof x.word === "string"
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "token-classification");
+  const { data: res } = await innerRequest(
+    args,
+    providerHelper,
+    {
+      ...options,
+      task: "token-classification"
+    }
   );
-  if (!isValidOutput) {
-    throw new InferenceOutputError(
-      "Expected Array<{end: number, entity_group: string, score: number, start: number, word: string}>"
-    );
-  }
-  return output;
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/translation.ts
 async function translation(args, options) {
-  const { data: res } = await innerRequest(args, {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "translation");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "translation"
   });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.translation_text === "string");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected type Array<{translation_text: string}>");
-  }
-  return res?.length === 1 ? res?.[0] : res;
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/nlp/zeroShotClassification.ts
 async function zeroShotClassification(args, options) {
-  const { data: res } = await innerRequest(args, {
-    ...options,
-    task: "zero-shot-classification"
-  });
-  const output = toArray(res);
-  const isValidOutput = Array.isArray(output) && output.every(
-    (x) => Array.isArray(x.labels) && x.labels.every((_label) => typeof _label === "string") && Array.isArray(x.scores) && x.scores.every((_score) => typeof _score === "number") && typeof x.sequence === "string"
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "zero-shot-classification");
+  const { data: res } = await innerRequest(
+    args,
+    providerHelper,
+    {
+      ...options,
+      task: "zero-shot-classification"
+    }
   );
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{labels: string[], scores: number[], sequence: string}>");
-  }
-  return output;
-}
-
-// src/tasks/nlp/chatCompletion.ts
-async function chatCompletion(args, options) {
-  const { data: res } = await innerRequest(args, {
-    ...options,
-    task: "text-generation",
-    chatCompletion: true
-  });
-  const isValidOutput = typeof res === "object" && Array.isArray(res?.choices) && typeof res?.created === "number" && typeof res?.id === "string" && typeof res?.model === "string" && /// Together.ai and Nebius do not output a system_fingerprint
-  (res.system_fingerprint === void 0 || res.system_fingerprint === null || typeof res.system_fingerprint === "string") && typeof res?.usage === "object";
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected ChatCompletionOutput");
-  }
-  return res;
-}
-
-// src/tasks/nlp/chatCompletionStream.ts
-async function* chatCompletionStream(args, options) {
-  yield* innerStreamingRequest(args, {
-    ...options,
-    task: "text-generation",
-    chatCompletion: true
-  });
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/multimodal/documentQuestionAnswering.ts
 async function documentQuestionAnswering(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "document-question-answering");
   const reqArgs = {
     ...args,
     inputs: {
@@ -1576,23 +1988,18 @@ async function documentQuestionAnswering(args, options) {
   };
   const { data: res } = await innerRequest(
     reqArgs,
+    providerHelper,
     {
       ...options,
       task: "document-question-answering"
     }
   );
-  const output = toArray(res);
-  const isValidOutput = Array.isArray(output) && output.every(
-    (elem) => typeof elem === "object" && !!elem && typeof elem?.answer === "string" && (typeof elem.end === "number" || typeof elem.end === "undefined") && (typeof elem.score === "number" || typeof elem.score === "undefined") && (typeof elem.start === "number" || typeof elem.start === "undefined")
-  );
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{answer: string, end?: number, score?: number, start?: number}>");
-  }
-  return output[0];
+  return providerHelper.getResponse(res);
 }
 
 // src/tasks/multimodal/visualQuestionAnswering.ts
 async function visualQuestionAnswering(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "visual-question-answering");
   const reqArgs = {
     ...args,
     inputs: {
@@ -1601,43 +2008,31 @@ async function visualQuestionAnswering(args, options) {
       image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer()))
     }
   };
-  const { data: res } = await innerRequest(reqArgs, {
+  const { data: res } = await innerRequest(reqArgs, providerHelper, {
     ...options,
     task: "visual-question-answering"
   });
-  const isValidOutput = Array.isArray(res) && res.every(
-    (elem) => typeof elem === "object" && !!elem && typeof elem?.answer === "string" && typeof elem.score === "number"
-  );
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{answer: string, score: number}>");
-  }
-  return res[0];
+  return providerHelper.getResponse(res);
 }
 
-// src/tasks/tabular/tabularRegression.ts
-async function tabularRegression(args, options) {
-  const { data: res } = await innerRequest(args, {
+// src/tasks/tabular/tabularClassification.ts
+async function tabularClassification(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-classification");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
-    task: "tabular-regression"
+    task: "tabular-classification"
   });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected number[]");
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
 
-// src/tasks/tabular/tabularClassification.ts
-async function tabularClassification(args, options) {
-  const { data: res } = await innerRequest(args, {
+// src/tasks/tabular/tabularRegression.ts
+async function tabularRegression(args, options) {
+  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-regression");
+  const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
-    task: "tabular-classification"
+    task: "tabular-regression"
   });
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x === "number");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected number[]");
-  }
-  return res;
+  return providerHelper.getResponse(res);
 }
 
 // src/InferenceClient.ts
@@ -1706,29 +2101,29 @@ __export(snippets_exports, {
 });
 
 // src/snippets/getInferenceSnippets.ts
+import { Template } from "@huggingface/jinja";
 import {
-  inferenceSnippetLanguages,
-  getModelInputSnippet
+  getModelInputSnippet,
+  inferenceSnippetLanguages
 } from "@huggingface/tasks";
-import { Template } from "@huggingface/jinja";
 
 // src/snippets/templates.exported.ts
 var templates = {
   "js": {
     "fetch": {
-      "basic": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
-      "basicAudio": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "audio/flac"\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
-      "basicImage": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "image/jpeg"\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
-      "textToAudio": '{% if model.library_name == "transformers" %}\nasync function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.blob();\n    return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    // Returns a byte object of the Audio wavform. Use it directly!\n});\n{% else %}\nasync function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n    const result = await response.json();\n    return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});\n{% endif %} ',
-      "textToImage": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.blob();\n	return result;\n}\n\n\nquery({ {{ providerInputs.asTsString }} }).then((response) => {\n    // Use image\n});',
-      "zeroShotClassification": 'async function query(data) {\n    const response = await fetch(\n		"{{ fullUrl }}",\n        {\n            headers: {\n				Authorization: "{{ authorizationHeader }}",\n                "Content-Type": "application/json",\n            },\n            method: "POST",\n            body: JSON.stringify(data),\n        }\n    );\n    const result = await response.json();\n    return result;\n}\n\nquery({\n    inputs: {{ providerInputs.asObj.inputs }},\n    parameters: { candidate_labels: ["refund", "legal", "faq"] }\n}).then((response) => {\n    console.log(JSON.stringify(response));\n});'
+      "basic": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n{% if billTo %}\n				"X-HF-Bill-To": "{{ billTo }}",\n{% endif %}			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
+      "basicAudio": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "audio/flac",\n{% if billTo %}\n				"X-HF-Bill-To": "{{ billTo }}",\n{% endif %}			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
+      "basicImage": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "image/jpeg",\n{% if billTo %}\n				"X-HF-Bill-To": "{{ billTo }}",\n{% endif %}			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
+      "textToAudio": '{% if model.library_name == "transformers" %}\nasync function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n{% if billTo %}\n				"X-HF-Bill-To": "{{ billTo }}",\n{% endif %}			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.blob();\n    return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    // Returns a byte object of the Audio wavform. Use it directly!\n});\n{% else %}\nasync function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n    const result = await response.json();\n    return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});\n{% endif %} ',
+      "textToImage": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n{% if billTo %}\n				"X-HF-Bill-To": "{{ billTo }}",\n{% endif %}			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.blob();\n	return result;\n}\n\n\nquery({ {{ providerInputs.asTsString }} }).then((response) => {\n    // Use image\n});',
+      "zeroShotClassification": 'async function query(data) {\n    const response = await fetch(\n		"{{ fullUrl }}",\n        {\n            headers: {\n				Authorization: "{{ authorizationHeader }}",\n                "Content-Type": "application/json",\n{% if billTo %}\n                "X-HF-Bill-To": "{{ billTo }}",\n{% endif %}         },\n            method: "POST",\n            body: JSON.stringify(data),\n        }\n    );\n    const result = await response.json();\n    return result;\n}\n\nquery({\n    inputs: {{ providerInputs.asObj.inputs }},\n    parameters: { candidate_labels: ["refund", "legal", "faq"] }\n}).then((response) => {\n    console.log(JSON.stringify(response));\n});'
     },
     "huggingface.js": {
-      "basic": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst output = await client.{{ methodName }}({\n	model: "{{ model.id }}",\n	inputs: {{ inputs.asObj.inputs }},\n	provider: "{{ provider }}",\n});\n\nconsole.log(output);',
-      "basicAudio": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst data = fs.readFileSync({{inputs.asObj.inputs}});\n\nconst output = await client.{{ methodName }}({\n	data,\n	model: "{{ model.id }}",\n	provider: "{{ provider }}",\n});\n\nconsole.log(output);',
-      "basicImage": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst data = fs.readFileSync({{inputs.asObj.inputs}});\n\nconst output = await client.{{ methodName }}({\n	data,\n	model: "{{ model.id }}",\n	provider: "{{ provider }}",\n});\n\nconsole.log(output);',
-      "conversational": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst chatCompletion = await client.chatCompletion({\n    provider: "{{ provider }}",\n    model: "{{ model.id }}",\n{{ inputs.asTsString }}\n});\n\nconsole.log(chatCompletion.choices[0].message);',
-      "conversationalStream": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nlet out = "";\n\nconst stream = await client.chatCompletionStream({\n    provider: "{{ provider }}",\n    model: "{{ model.id }}",\n{{ inputs.asTsString }}\n});\n\nfor await (const chunk of stream) {\n	if (chunk.choices && chunk.choices.length > 0) {\n		const newContent = chunk.choices[0].delta.content;\n		out += newContent;\n		console.log(newContent);\n	}  \n}',
+      "basic": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst output = await client.{{ methodName }}({\n	model: "{{ model.id }}",\n	inputs: {{ inputs.asObj.inputs }},\n	provider: "{{ provider }}",\n}{% if billTo %}, {\n	billTo: "{{ billTo }}",\n}{% endif %});\n\nconsole.log(output);',
+      "basicAudio": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst data = fs.readFileSync({{inputs.asObj.inputs}});\n\nconst output = await client.{{ methodName }}({\n	data,\n	model: "{{ model.id }}",\n	provider: "{{ provider }}",\n}{% if billTo %}, {\n	billTo: "{{ billTo }}",\n}{% endif %});\n\nconsole.log(output);',
+      "basicImage": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst data = fs.readFileSync({{inputs.asObj.inputs}});\n\nconst output = await client.{{ methodName }}({\n	data,\n	model: "{{ model.id }}",\n	provider: "{{ provider }}",\n}{% if billTo %}, {\n	billTo: "{{ billTo }}",\n}{% endif %});\n\nconsole.log(output);',
+      "conversational": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nconst chatCompletion = await client.chatCompletion({\n    provider: "{{ provider }}",\n    model: "{{ model.id }}",\n{{ inputs.asTsString }}\n}{% if billTo %}, {\n    billTo: "{{ billTo }}",\n}{% endif %});\n\nconsole.log(chatCompletion.choices[0].message);',
+      "conversationalStream": 'import { InferenceClient } from "@huggingface/inference";\n\nconst client = new InferenceClient("{{ accessToken }}");\n\nlet out = "";\n\nconst stream = await client.chatCompletionStream({\n    provider: "{{ provider }}",\n    model: "{{ model.id }}",\n{{ inputs.asTsString }}\n}{% if billTo %}, {\n    billTo: "{{ billTo }}",\n}{% endif %});\n\nfor await (const chunk of stream) {\n	if (chunk.choices && chunk.choices.length > 0) {\n		const newContent = chunk.choices[0].delta.content;\n		out += newContent;\n		console.log(newContent);\n	}  \n}',
       "textToImage": `import { InferenceClient } from "@huggingface/inference";
 
 const client = new InferenceClient("{{ accessToken }}");
@@ -1738,7 +2133,9 @@ const image = await client.textToImage({
     model: "{{ model.id }}",
 	inputs: {{ inputs.asObj.inputs }},
 	parameters: { num_inference_steps: 5 },
-});
+}{% if billTo %}, {
+    billTo: "{{ billTo }}",
+}{% endif %});
 /// Use the generated image (it's a Blob)`,
       "textToVideo": `import { InferenceClient } from "@huggingface/inference";
 
@@ -1748,12 +2145,14 @@ const image = await client.textToVideo({
     provider: "{{ provider }}",
     model: "{{ model.id }}",
 	inputs: {{ inputs.asObj.inputs }},
-});
+}{% if billTo %}, {
+    billTo: "{{ billTo }}",
+}{% endif %});
 // Use the generated video (it's a Blob)`
     },
     "openai": {
-      "conversational": 'import { OpenAI } from "openai";\n\nconst client = new OpenAI({\n	baseURL: "{{ baseUrl }}",\n	apiKey: "{{ accessToken }}",\n});\n\nconst chatCompletion = await client.chat.completions.create({\n	model: "{{ providerModelId }}",\n{{ inputs.asTsString }}\n});\n\nconsole.log(chatCompletion.choices[0].message);',
-      "conversationalStream": 'import { OpenAI } from "openai";\n\nconst client = new OpenAI({\n	baseURL: "{{ baseUrl }}",\n	apiKey: "{{ accessToken }}",\n});\n\nlet out = "";\n\nconst stream = await client.chat.completions.create({\n    provider: "{{ provider }}",\n    model: "{{ model.id }}",\n{{ inputs.asTsString }}\n});\n\nfor await (const chunk of stream) {\n	if (chunk.choices && chunk.choices.length > 0) {\n		const newContent = chunk.choices[0].delta.content;\n		out += newContent;\n		console.log(newContent);\n	}  \n}'
+      "conversational": 'import { OpenAI } from "openai";\n\nconst client = new OpenAI({\n	baseURL: "{{ baseUrl }}",\n	apiKey: "{{ accessToken }}",\n{% if billTo %}\n	defaultHeaders: {\n		"X-HF-Bill-To": "{{ billTo }}" \n	}\n{% endif %}\n});\n\nconst chatCompletion = await client.chat.completions.create({\n	model: "{{ providerModelId }}",\n{{ inputs.asTsString }}\n});\n\nconsole.log(chatCompletion.choices[0].message);',
+      "conversationalStream": 'import { OpenAI } from "openai";\n\nconst client = new OpenAI({\n	baseURL: "{{ baseUrl }}",\n	apiKey: "{{ accessToken }}",\n{% if billTo %}\n    defaultHeaders: {\n		"X-HF-Bill-To": "{{ billTo }}" \n	}\n{% endif %}\n});\n\nconst stream = await client.chat.completions.create({\n    model: "{{ providerModelId }}",\n{{ inputs.asTsString }}\n    stream: true,\n});\n\nfor await (const chunk of stream) {\n    process.stdout.write(chunk.choices[0]?.delta?.content || "");\n}'
     }
   },
   "python": {
@@ -1768,13 +2167,13 @@ const image = await client.textToVideo({
       "conversationalStream": 'stream = client.chat.completions.create(\n    model="{{ model.id }}",\n{{ inputs.asPythonString }}\n    stream=True,\n)\n\nfor chunk in stream:\n    print(chunk.choices[0].delta.content, end="") ',
       "documentQuestionAnswering": 'output = client.document_question_answering(\n    "{{ inputs.asObj.image }}",\n    question="{{ inputs.asObj.question }}",\n    model="{{ model.id }}",\n) ',
       "imageToImage": '# output is a PIL.Image object\nimage = client.image_to_image(\n    "{{ inputs.asObj.inputs }}",\n    prompt="{{ inputs.asObj.parameters.prompt }}",\n    model="{{ model.id }}",\n) ',
-      "importInferenceClient": 'from huggingface_hub import InferenceClient\n\nclient = InferenceClient(\n    provider="{{ provider }}",\n    api_key="{{ accessToken }}",\n)',
+      "importInferenceClient": 'from huggingface_hub import InferenceClient\n\nclient = InferenceClient(\n    provider="{{ provider }}",\n    api_key="{{ accessToken }}",\n{% if billTo %}\n    bill_to="{{ billTo }}",\n{% endif %}\n)',
       "textToImage": '# output is a PIL.Image object\nimage = client.text_to_image(\n    {{ inputs.asObj.inputs }},\n    model="{{ model.id }}",\n) ',
       "textToVideo": 'video = client.text_to_video(\n    {{ inputs.asObj.inputs }},\n    model="{{ model.id }}",\n) '
     },
     "openai": {
-      "conversational": 'from openai import OpenAI\n\nclient = OpenAI(\n    base_url="{{ baseUrl }}",\n    api_key="{{ accessToken }}"\n)\n\ncompletion = client.chat.completions.create(\n    model="{{ providerModelId }}",\n{{ inputs.asPythonString }}\n)\n\nprint(completion.choices[0].message) ',
-      "conversationalStream": 'from openai import OpenAI\n\nclient = OpenAI(\n    base_url="{{ baseUrl }}",\n    api_key="{{ accessToken }}"\n)\n\nstream = client.chat.completions.create(\n    model="{{ providerModelId }}",\n{{ inputs.asPythonString }}\n    stream=True,\n)\n\nfor chunk in stream:\n    print(chunk.choices[0].delta.content, end="")'
+      "conversational": 'from openai import OpenAI\n\nclient = OpenAI(\n    base_url="{{ baseUrl }}",\n    api_key="{{ accessToken }}",\n{% if billTo %}\n    default_headers={\n        "X-HF-Bill-To": "{{ billTo }}"\n    }\n{% endif %}\n)\n\ncompletion = client.chat.completions.create(\n    model="{{ providerModelId }}",\n{{ inputs.asPythonString }}\n)\n\nprint(completion.choices[0].message) ',
+      "conversationalStream": 'from openai import OpenAI\n\nclient = OpenAI(\n    base_url="{{ baseUrl }}",\n    api_key="{{ accessToken }}",\n{% if billTo %}\n    default_headers={\n        "X-HF-Bill-To": "{{ billTo }}"\n    }\n{% endif %}\n)\n\nstream = client.chat.completions.create(\n    model="{{ providerModelId }}",\n{{ inputs.asPythonString }}\n    stream=True,\n)\n\nfor chunk in stream:\n    print(chunk.choices[0].delta.content, end="")'
     },
     "requests": {
       "basic": 'def query(payload):\n    response = requests.post(API_URL, headers=headers, json=payload)\n    return response.json()\n\noutput = query({\n    "inputs": {{ providerInputs.asObj.inputs }},\n}) ',
@@ -1784,7 +2183,7 @@ const image = await client.textToVideo({
       "conversationalStream": 'def query(payload):\n    response = requests.post(API_URL, headers=headers, json=payload, stream=True)\n    for line in response.iter_lines():\n        if not line.startswith(b"data:"):\n            continue\n        if line.strip() == b"data: [DONE]":\n            return\n        yield json.loads(line.decode("utf-8").lstrip("data:").rstrip("/n"))\n\nchunks = query({\n{{ providerInputs.asJsonString }},\n    "stream": True,\n})\n\nfor chunk in chunks:\n    print(chunk["choices"][0]["delta"]["content"], end="")',
       "documentQuestionAnswering": 'def query(payload):\n    with open(payload["image"], "rb") as f:\n        img = f.read()\n        payload["image"] = base64.b64encode(img).decode("utf-8")\n    response = requests.post(API_URL, headers=headers, json=payload)\n    return response.json()\n\noutput = query({\n    "inputs": {\n        "image": "{{ inputs.asObj.image }}",\n        "question": "{{ inputs.asObj.question }}",\n    },\n}) ',
       "imageToImage": 'def query(payload):\n    with open(payload["inputs"], "rb") as f:\n        img = f.read()\n        payload["inputs"] = base64.b64encode(img).decode("utf-8")\n    response = requests.post(API_URL, headers=headers, json=payload)\n    return response.content\n\nimage_bytes = query({\n{{ providerInputs.asJsonString }}\n})\n\n# You can access the image with PIL.Image for example\nimport io\nfrom PIL import Image\nimage = Image.open(io.BytesIO(image_bytes)) ',
-      "importRequests": '{% if importBase64 %}\nimport base64\n{% endif %}\n{% if importJson %}\nimport json\n{% endif %}\nimport requests\n\nAPI_URL = "{{ fullUrl }}"\nheaders = {"Authorization": "{{ authorizationHeader }}"}',
+      "importRequests": '{% if importBase64 %}\nimport base64\n{% endif %}\n{% if importJson %}\nimport json\n{% endif %}\nimport requests\n\nAPI_URL = "{{ fullUrl }}"\nheaders = {\n    "Authorization": "{{ authorizationHeader }}",\n{% if billTo %}\n    "X-HF-Bill-To": "{{ billTo }}"\n{% endif %}\n}',
       "tabular": 'def query(payload):\n    response = requests.post(API_URL, headers=headers, json=payload)\n    return response.content\n\nresponse = query({\n    "inputs": {\n        "data": {{ providerInputs.asObj.inputs }}\n    },\n}) ',
       "textToAudio": '{% if model.library_name == "transformers" %}\ndef query(payload):\n    response = requests.post(API_URL, headers=headers, json=payload)\n    return response.content\n\naudio_bytes = query({\n    "inputs": {{ providerInputs.asObj.inputs }},\n})\n# You can access the audio with IPython.display for example\nfrom IPython.display import Audio\nAudio(audio_bytes)\n{% else %}\ndef query(payload):\n    response = requests.post(API_URL, headers=headers, json=payload)\n    return response.json()\n\naudio, sampling_rate = query({\n    "inputs": {{ providerInputs.asObj.inputs }},\n})\n# You can access the audio with IPython.display for example\nfrom IPython.display import Audio\nAudio(audio, rate=sampling_rate)\n{% endif %} ',
       "textToImage": '{% if provider == "hf-inference" %}\ndef query(payload):\n    response = requests.post(API_URL, headers=headers, json=payload)\n    return response.content\n\nimage_bytes = query({\n    "inputs": {{ providerInputs.asObj.inputs }},\n})\n\n# You can access the image with PIL.Image for example\nimport io\nfrom PIL import Image\nimage = Image.open(io.BytesIO(image_bytes))\n{% endif %}',
@@ -1794,12 +2193,15 @@ const image = await client.textToVideo({
   },
   "sh": {
     "curl": {
-      "basic": "curl {{ fullUrl }} \\\n    -X POST \\\n    -H 'Authorization: {{ authorizationHeader }}' \\\n    -H 'Content-Type: application/json' \\\n    -d '{\n{{ providerInputs.asCurlString }}\n    }'",
-      "basicAudio": "curl {{ fullUrl }} \\\n    -X POST \\\n    -H 'Authorization: {{ authorizationHeader }}' \\\n    -H 'Content-Type: audio/flac' \\\n    --data-binary @{{ providerInputs.asObj.inputs }}",
-      "basicImage": "curl {{ fullUrl }} \\\n    -X POST \\\n    -H 'Authorization: {{ authorizationHeader }}' \\\n    -H 'Content-Type: image/jpeg' \\\n    --data-binary @{{ providerInputs.asObj.inputs }}",
+      "basic": "curl {{ fullUrl }} \\\n    -X POST \\\n    -H 'Authorization: {{ authorizationHeader }}' \\\n    -H 'Content-Type: application/json' \\\n{% if billTo %}\n    -H 'X-HF-Bill-To: {{ billTo }}' \\\n{% endif %}\n    -d '{\n{{ providerInputs.asCurlString }}\n    }'",
+      "basicAudio": "curl {{ fullUrl }} \\\n    -X POST \\\n    -H 'Authorization: {{ authorizationHeader }}' \\\n    -H 'Content-Type: audio/flac' \\\n{% if billTo %}\n    -H 'X-HF-Bill-To: {{ billTo }}' \\\n{% endif %}\n    --data-binary @{{ providerInputs.asObj.inputs }}",
+      "basicImage": "curl {{ fullUrl }} \\\n    -X POST \\\n    -H 'Authorization: {{ authorizationHeader }}' \\\n    -H 'Content-Type: image/jpeg' \\\n{% if billTo %}\n    -H 'X-HF-Bill-To: {{ billTo }}' \\\n{% endif %}\n    --data-binary @{{ providerInputs.asObj.inputs }}",
       "conversational": `curl {{ fullUrl }} \\
     -H 'Authorization: {{ authorizationHeader }}' \\
     -H 'Content-Type: application/json' \\
+{% if billTo %}
+    -H 'X-HF-Bill-To: {{ billTo }}' \\
+{% endif %}
     -d '{
 {{ providerInputs.asCurlString }},
         "stream": false
@@ -1807,6 +2209,9 @@ const image = await client.textToVideo({
       "conversationalStream": `curl {{ fullUrl }} \\
     -H 'Authorization: {{ authorizationHeader }}' \\
     -H 'Content-Type: application/json' \\
+{% if billTo %}
+    -H 'X-HF-Bill-To: {{ billTo }}' \\
+{% endif %}
     -d '{
 {{ providerInputs.asCurlString }},
         "stream": true
@@ -1815,7 +2220,10 @@ const image = await client.textToVideo({
     -X POST \\
     -d '{"inputs": {{ providerInputs.asObj.inputs }}, "parameters": {"candidate_labels": ["refund", "legal", "faq"]}}' \\
     -H 'Content-Type: application/json' \\
-    -H 'Authorization: {{ authorizationHeader }}'`
+    -H 'Authorization: {{ authorizationHeader }}'
+{% if billTo %} \\
+    -H 'X-HF-Bill-To: {{ billTo }}'
+{% endif %}`
     }
   }
 };
@@ -1884,16 +2292,35 @@ var HF_JS_METHODS = {
   translation: "translation"
 };
 var snippetGenerator = (templateName, inputPreparationFn) => {
-  return (model, accessToken, provider, providerModelId, opts) => {
+  return (model, accessToken, provider, inferenceProviderMapping, billTo, opts) => {
+    const providerModelId = inferenceProviderMapping?.providerId ?? model.id;
+    let task = model.pipeline_tag;
     if (model.pipeline_tag && ["text-generation", "image-text-to-text"].includes(model.pipeline_tag) && model.tags.includes("conversational")) {
       templateName = opts?.streaming ? "conversationalStream" : "conversational";
       inputPreparationFn = prepareConversationalInput;
+      task = "conversational";
+    }
+    let providerHelper;
+    try {
+      providerHelper = getProviderHelper(provider, task);
+    } catch (e) {
+      console.error(`Failed to get provider helper for ${provider} (${task})`, e);
+      return [];
     }
     const inputs = inputPreparationFn ? inputPreparationFn(model, opts) : { inputs: getModelInputSnippet(model) };
     const request2 = makeRequestOptionsFromResolvedModel(
-      providerModelId ?? model.id,
-      { accessToken, provider, ...inputs },
-      { chatCompletion: templateName.includes("conversational"), task: model.pipeline_tag }
+      providerModelId,
+      providerHelper,
+      {
+        accessToken,
+        provider,
+        ...inputs
+      },
+      inferenceProviderMapping,
+      {
+        task,
+        billTo
+      }
     );
     let providerInputs = inputs;
     const bodyAsObj = request2.info.body;
@@ -1925,7 +2352,8 @@ var snippetGenerator = (templateName, inputPreparationFn) => {
       },
       model,
       provider,
-      providerModelId: providerModelId ?? model.id
+      providerModelId: providerModelId ?? model.id,
+      billTo
     };
     return inferenceSnippetLanguages.map((language) => {
       return CLIENTS[language].map((client) => {
@@ -1980,7 +2408,7 @@ var prepareConversationalInput = (model, opts) => {
   return {
     messages: opts?.messages ?? getModelInputSnippet(model),
     ...opts?.temperature ? { temperature: opts?.temperature } : void 0,
-    max_tokens: opts?.max_tokens ?? 500,
+    max_tokens: opts?.max_tokens ?? 512,
     ...opts?.top_p ? { top_p: opts?.top_p } : void 0
   };
 };
@@ -2015,8 +2443,8 @@ var snippets = {
   "zero-shot-classification": snippetGenerator("zeroShotClassification"),
   "zero-shot-image-classification": snippetGenerator("zeroShotImageClassification")
 };
-function getInferenceSnippets(model, accessToken, provider, providerModelId, opts) {
-  return model.pipeline_tag && model.pipeline_tag in snippets ? snippets[model.pipeline_tag]?.(model, accessToken, provider, providerModelId, opts) ?? [] : [];
+function getInferenceSnippets(model, accessToken, provider, inferenceProviderMapping, billTo, opts) {
+  return model.pipeline_tag && model.pipeline_tag in snippets ? snippets[model.pipeline_tag]?.(model, accessToken, provider, inferenceProviderMapping, billTo, opts) ?? [] : [];
 }
 function formatBody(obj, format) {
   switch (format) {