@huggingface/inference 3.10.0 → 3.12.0

package/dist/index.js

@@ -41,6 +41,38 @@ __export(tasks_exports, {
   zeroShotImageClassification: () => zeroShotImageClassification
 });
 
+// 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/consts.ts
+var HARDCODED_MODEL_INFERENCE_MAPPING = {
+  /**
+   * "HF model ID" => "Model ID on Inference Provider's side"
+   *
+   * Example:
+   * "Qwen/Qwen2.5-Coder-32B-Instruct": "Qwen2.5-Coder-32B-Instruct",
+   */
+  "black-forest-labs": {},
+  cerebras: {},
+  cohere: {},
+  "fal-ai": {},
+  "featherless-ai": {},
+  "fireworks-ai": {},
+  groq: {},
+  "hf-inference": {},
+  hyperbolic: {},
+  nebius: {},
+  novita: {},
+  nscale: {},
+  openai: {},
+  ovhcloud: {},
+  replicate: {},
+  sambanova: {},
+  together: {}
+};
+
 // src/lib/InferenceOutputError.ts
 var InferenceOutputError = class extends TypeError {
   constructor(message) {
@@ -51,42 +83,6 @@ var InferenceOutputError = class extends TypeError {
   }
 };
 
-// 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/utils/toArray.ts
 function toArray(obj) {
   if (Array.isArray(obj)) {
@@ -181,627 +177,736 @@ var BaseTextGenerationTask = class extends TaskProviderHelper {
   }
 };
 
-// src/providers/black-forest-labs.ts
-var BLACK_FOREST_LABS_AI_API_BASE_URL = "https://api.us1.bfl.ai";
-var BlackForestLabsTextToImageTask = class extends TaskProviderHelper {
+// src/providers/hf-inference.ts
+var EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS = ["feature-extraction", "sentence-similarity"];
+var HFInferenceTask = class extends TaskProviderHelper {
   constructor() {
-    super("black-forest-labs", BLACK_FOREST_LABS_AI_API_BASE_URL);
+    super("hf-inference", `${HF_ROUTER_URL}/hf-inference`);
   }
   preparePayload(params) {
-    return {
-      ...omit(params.args, ["inputs", "parameters"]),
-      ...params.args.parameters,
-      prompt: params.args.inputs
-    };
+    return params.args;
   }
-  prepareHeaders(params, binary) {
-    const headers = {
-      Authorization: params.authMethod !== "provider-key" ? `Bearer ${params.accessToken}` : `X-Key ${params.accessToken}`
-    };
-    if (!binary) {
-      headers["Content-Type"] = "application/json";
+  makeUrl(params) {
+    if (params.model.startsWith("http://") || params.model.startsWith("https://")) {
+      return params.model;
     }
-    return headers;
+    return super.makeUrl(params);
   }
   makeRoute(params) {
-    if (!params) {
-      throw new Error("Params are required");
+    if (params.task && ["feature-extraction", "sentence-similarity"].includes(params.task)) {
+      return `models/${params.model}/pipeline/${params.task}`;
     }
-    return `/v1/${params.model}`;
+    return `models/${params.model}`;
+  }
+  async getResponse(response) {
+    return response;
   }
+};
+var HFInferenceTextToImageTask = class extends HFInferenceTask {
   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");
+    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();
       }
-      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 ("output" in response && Array.isArray(response.output)) {
         if (outputType === "url") {
-          return payload.result.sample;
+          return response.output[0];
         }
-        const image = await fetch(payload.result.sample);
-        return await image.blob();
+        const urlResponse = await fetch(response.output[0]);
+        const blob = await urlResponse.blob();
+        return blob;
       }
     }
-    throw new InferenceOutputError("Failed to fetch result from black forest labs API");
+    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 ");
   }
 };
-
-// src/providers/cerebras.ts
-var CerebrasConversationalTask = class extends BaseConversationalTask {
-  constructor() {
-    super("cerebras", "https://api.cerebras.ai");
+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;
   }
 };
-
-// src/providers/cohere.ts
-var CohereConversationalTask = class extends BaseConversationalTask {
-  constructor() {
-    super("cohere", "https://api.cohere.com");
+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}>");
   }
-  makeRoute() {
-    return "/compatibility/v1/chat/completions";
+};
+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");
   }
 };
-
-// src/lib/isUrl.ts
-function isUrl(modelOrUrl) {
-  return /^http(s?):/.test(modelOrUrl) || modelOrUrl.startsWith("/");
-}
-
-// src/providers/fal-ai.ts
-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");
+var HFInferenceAutomaticSpeechRecognitionTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    return response;
   }
-  preparePayload(params) {
-    return params.args;
+};
+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;
   }
-  makeRoute(params) {
-    return `/${params.model}`;
+};
+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}>");
   }
-  prepareHeaders(params, binary) {
-    const headers = {
-      Authorization: params.authMethod !== "provider-key" ? `Bearer ${params.accessToken}` : `Key ${params.accessToken}`
+};
+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 (!binary) {
-      headers["Content-Type"] = "application/json";
+    if (Array.isArray(response) && isNumArrayRec(response, 3, 0)) {
+      return response;
     }
-    return headers;
+    throw new InferenceOutputError("Expected Array<number[][][] | number[][] | number[] | number>");
   }
 };
-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
-    };
-    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";
-      }
+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;
     }
-    return payload;
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
   }
-  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();
+};
+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 Fal.ai text-to-image response format");
+    throw new InferenceOutputError("Expected Array<{label: string, mask: string, score: number}>");
   }
 };
-var FalAITextToVideoTask = class extends FalAITask {
-  constructor() {
-    super("https://queue.fal.run");
-  }
-  makeRoute(params) {
-    if (params.authMethod !== "provider-key") {
-      return `/${params.model}?_subdomain=queue`;
+var HFInferenceImageToTextTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (typeof response?.generated_text !== "string") {
+      throw new InferenceOutputError("Expected {generated_text: string}");
     }
-    return `/${params.model}`;
+    return response;
   }
-  preparePayload(params) {
-    return {
-      ...omit(params.args, ["inputs", "parameters"]),
-      ...params.args.parameters,
-      prompt: params.args.inputs
-    };
+};
+var HFInferenceImageToImageTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    if (response instanceof Blob) {
+      return response;
+    }
+    throw new InferenceOutputError("Expected Blob");
   }
-  async getResponse(response, url, headers) {
-    if (!url || !headers) {
-      throw new InferenceOutputError("URL and headers are required for text-to-video task");
+};
+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;
     }
-    const requestId = response.request_id;
-    if (!requestId) {
-      throw new InferenceOutputError("No request ID found in the response");
+    throw new InferenceOutputError(
+      "Expected Array<{label: string, score: number, box: {xmin: number, ymin: number, xmax: number, ymax: number}}>"
+    );
+  }
+};
+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;
     }
-    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");
-      }
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
+  }
+};
+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;
     }
-    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");
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
+  }
+};
+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;
     }
-    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)
-      );
+    throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
+  }
+};
+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}>"
+    );
   }
 };
-var FalAIAutomaticSpeechRecognitionTask = class extends FalAITask {
-  prepareHeaders(params, binary) {
-    const headers = super.prepareHeaders(params, binary);
-    headers["Content-Type"] = "application/json";
-    return headers;
+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 HFInferenceSentenceSimilarityTask = class extends HFInferenceTask {
   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)}`
-      );
+    if (Array.isArray(response) && response.every((x) => typeof x === "number")) {
+      return response;
     }
-    return { text: res.text };
+    throw new InferenceOutputError("Expected Array<number>");
   }
 };
-var FalAITextToSpeechTask = class extends FalAITask {
-  preparePayload(params) {
-    return {
-      ...omit(params.args, ["inputs", "parameters"]),
-      ...params.args.parameters,
-      text: params.args.inputs
-    };
+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) {
-    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)}`
-      );
+    if (Array.isArray(response) && Array.isArray(response) ? response.every((elem) => HFInferenceTableQuestionAnsweringTask.validate(elem)) : HFInferenceTableQuestionAnsweringTask.validate(response)) {
+      return Array.isArray(response) ? response[0] : response;
     }
-    try {
-      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(
-        `Error fetching or processing audio from Fal.ai Text-to-Speech URL: ${res.audio.url}. ${error instanceof Error ? error.message : String(error)}`
-      );
+    throw new InferenceOutputError(
+      "Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}"
+    );
+  }
+};
+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}>"
+    );
   }
 };
-
-// src/providers/featherless-ai.ts
-var FEATHERLESS_API_BASE_URL = "https://api.featherless.ai";
-var FeatherlessAIConversationalTask = class extends BaseConversationalTask {
-  constructor() {
-    super("featherless-ai", FEATHERLESS_API_BASE_URL);
+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 FeatherlessAITextGenerationTask = class extends BaseTextGenerationTask {
-  constructor() {
-    super("featherless-ai", FEATHERLESS_API_BASE_URL);
+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}>");
   }
-  preparePayload(params) {
-    return {
-      ...params.args,
-      ...params.args.parameters,
-      model: params.model,
-      prompt: params.args.inputs
-    };
+};
+var HFInferenceTextToSpeechTask = class extends HFInferenceTask {
+  async getResponse(response) {
+    return response;
   }
+};
+var HFInferenceTabularClassificationTask = class extends HFInferenceTask {
   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
-      };
+    if (Array.isArray(response) && response.every((x) => typeof x === "number")) {
+      return response;
     }
-    throw new InferenceOutputError("Expected Featherless AI text generation response format");
+    throw new InferenceOutputError("Expected Array<number>");
   }
 };
-
-// src/providers/fireworks-ai.ts
-var FireworksConversationalTask = class extends BaseConversationalTask {
-  constructor() {
-    super("fireworks-ai", "https://api.fireworks.ai");
+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}>");
   }
-  makeRoute() {
-    return "/inference/v1/chat/completions";
+};
+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/groq.ts
-var GROQ_API_BASE_URL = "https://api.groq.com";
-var GroqTextGenerationTask = class extends BaseTextGenerationTask {
-  constructor() {
-    super("groq", GROQ_API_BASE_URL);
+// src/utils/typedInclude.ts
+function typedInclude(arr, v) {
+  return arr.includes(v);
+}
+
+// src/lib/getInferenceProviderMapping.ts
+var inferenceProviderMappingCache = /* @__PURE__ */ new Map();
+async function fetchInferenceProviderMappingForModel(modelId, accessToken, options) {
+  let inferenceProviderMapping;
+  if (inferenceProviderMappingCache.has(modelId)) {
+    inferenceProviderMapping = inferenceProviderMappingCache.get(modelId);
+  } else {
+    const resp = await (options?.fetch ?? fetch)(
+      `${HF_HUB_URL}/api/models/${modelId}?expand[]=inferenceProviderMapping`,
+      {
+        headers: accessToken?.startsWith("hf_") ? { Authorization: `Bearer ${accessToken}` } : {}
+      }
+    );
+    if (resp.status === 404) {
+      throw new Error(`Model ${modelId} does not exist`);
+    }
+    inferenceProviderMapping = await resp.json().then((json) => json.inferenceProviderMapping).catch(() => null);
+    if (inferenceProviderMapping) {
+      inferenceProviderMappingCache.set(modelId, inferenceProviderMapping);
+    }
   }
-  makeRoute() {
-    return "/openai/v1/chat/completions";
+  if (!inferenceProviderMapping) {
+    throw new Error(`We have not been able to find inference provider information for model ${modelId}.`);
   }
-};
-var GroqConversationalTask = class extends BaseConversationalTask {
-  constructor() {
-    super("groq", GROQ_API_BASE_URL);
+  return inferenceProviderMapping;
+}
+async function getInferenceProviderMapping(params, options) {
+  if (HARDCODED_MODEL_INFERENCE_MAPPING[params.provider][params.modelId]) {
+    return HARDCODED_MODEL_INFERENCE_MAPPING[params.provider][params.modelId];
   }
-  makeRoute() {
-    return "/openai/v1/chat/completions";
+  const inferenceProviderMapping = await fetchInferenceProviderMappingForModel(
+    params.modelId,
+    params.accessToken,
+    options
+  );
+  const providerMapping = inferenceProviderMapping[params.provider];
+  if (providerMapping) {
+    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.modelId} is not supported for task ${params.task} and provider ${params.provider}. Supported task: ${providerMapping.task}.`
+      );
+    }
+    if (providerMapping.status === "staging") {
+      console.warn(
+        `Model ${params.modelId} is in staging mode for provider ${params.provider}. Meant for test purposes only.`
+      );
+    }
+    return { ...providerMapping, hfModelId: params.modelId };
   }
-};
+  return null;
+}
+async function resolveProvider(provider, modelId, endpointUrl) {
+  if (endpointUrl) {
+    if (provider) {
+      throw new Error("Specifying both endpointUrl and provider is not supported.");
+    }
+    return "hf-inference";
+  }
+  if (!provider) {
+    console.log(
+      "Defaulting to 'auto' which will select the first provider available for the model, sorted by the user's order in https://hf.co/settings/inference-providers."
+    );
+    provider = "auto";
+  }
+  if (provider === "auto") {
+    if (!modelId) {
+      throw new Error("Specifying a model is required when provider is 'auto'");
+    }
+    const inferenceProviderMapping = await fetchInferenceProviderMappingForModel(modelId);
+    provider = Object.keys(inferenceProviderMapping)[0];
+  }
+  if (!provider) {
+    throw new Error(`No Inference Provider available for model ${modelId}.`);
+  }
+  return provider;
+}
 
-// src/providers/hf-inference.ts
-var EQUIVALENT_SENTENCE_TRANSFORMERS_TASKS = ["feature-extraction", "sentence-similarity"];
-var HFInferenceTask = class extends TaskProviderHelper {
+// 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/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/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("hf-inference", `${HF_ROUTER_URL}/hf-inference`);
+    super("black-forest-labs", BLACK_FOREST_LABS_AI_API_BASE_URL);
   }
   preparePayload(params) {
-    return params.args;
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      prompt: params.args.inputs
+    };
   }
-  makeUrl(params) {
-    if (params.model.startsWith("http://") || params.model.startsWith("https://")) {
-      return params.model;
+  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 super.makeUrl(params);
+    return headers;
   }
   makeRoute(params) {
-    if (params.task && ["feature-extraction", "sentence-similarity"].includes(params.task)) {
-      return `pipeline/${params.task}/${params.model}`;
+    if (!params) {
+      throw new Error("Params are required");
     }
-    return `models/${params.model}`;
-  }
-  async getResponse(response) {
-    return response;
+    return `/v1/${params.model}`;
   }
-};
-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();
+    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");
       }
-      if ("output" in response && Array.isArray(response.output)) {
+      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 response.output[0];
+          return payload.result.sample;
         }
-        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}`;
+        const image = await fetch(payload.result.sample);
+        return await image.blob();
       }
-      return response;
     }
-    throw new InferenceOutputError("Expected a Blob ");
+    throw new InferenceOutputError("Failed to fetch result from black forest labs API");
   }
 };
-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;
+
+// src/providers/cerebras.ts
+var CerebrasConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("cerebras", "https://api.cerebras.ai");
   }
-  preparePayload(params) {
-    return {
-      ...params.args,
-      model: params.model
-    };
+};
+
+// src/providers/cohere.ts
+var CohereConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("cohere", "https://api.cohere.com");
   }
-  async getResponse(response) {
-    return response;
+  makeRoute() {
+    return "/compatibility/v1/chat/completions";
   }
 };
-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}>");
+
+// src/lib/isUrl.ts
+function isUrl(modelOrUrl) {
+  return /^http(s?):/.test(modelOrUrl) || modelOrUrl.startsWith("/");
+}
+
+// src/providers/fal-ai.ts
+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");
   }
-};
-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");
+  preparePayload(params) {
+    return params.args;
   }
-};
-var HFInferenceAutomaticSpeechRecognitionTask = class extends HFInferenceTask {
-  async getResponse(response) {
-    return response;
+  makeRoute(params) {
+    return `/${params.model}`;
   }
-};
-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}>");
+  prepareHeaders(params, binary) {
+    const headers = {
+      Authorization: params.authMethod !== "provider-key" ? `Bearer ${params.accessToken}` : `Key ${params.accessToken}`
+    };
+    if (!binary) {
+      headers["Content-Type"] = "application/json";
     }
-    return response;
+    return headers;
   }
 };
-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];
+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
+    };
+    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";
+      }
     }
-    throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
+    return payload;
   }
-};
-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");
+  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;
       }
-    };
-    if (Array.isArray(response) && isNumArrayRec(response, 3, 0)) {
-      return response;
+      const urlResponse = await fetch(response.images[0].url);
+      return await urlResponse.blob();
     }
-    throw new InferenceOutputError("Expected Array<number[][][] | number[][] | number[] | number>");
+    throw new InferenceOutputError("Expected Fal.ai text-to-image response format");
   }
 };
-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 FalAITextToVideoTask = class extends FalAITask {
+  constructor() {
+    super("https://queue.fal.run");
   }
-};
-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;
+  makeRoute(params) {
+    if (params.authMethod !== "provider-key") {
+      return `/${params.model}?_subdomain=queue`;
     }
-    throw new InferenceOutputError("Expected Array<{label: string, mask: string, score: number}>");
+    return `/${params.model}`;
   }
-};
-var HFInferenceImageToTextTask = class extends HFInferenceTask {
-  async getResponse(response) {
-    if (typeof response?.generated_text !== "string") {
-      throw new InferenceOutputError("Expected {generated_text: string}");
-    }
-    return response;
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      prompt: params.args.inputs
+    };
   }
-};
-var HFInferenceImageToImageTask = class extends HFInferenceTask {
-  async getResponse(response) {
-    if (response instanceof Blob) {
-      return response;
+  async getResponse(response, url, headers) {
+    if (!url || !headers) {
+      throw new InferenceOutputError("URL and headers are required for text-to-video task");
     }
-    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;
+    const requestId = response.request_id;
+    if (!requestId) {
+      throw new InferenceOutputError("No request ID found in the response");
     }
-    throw new InferenceOutputError(
-      "Expected Array<{label: string, score: number, box: {xmin: number, ymin: number, xmax: number, ymax: number}}>"
-    );
-  }
-};
-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;
+    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)
+      );
     }
-    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
   }
 };
-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 FalAIAutomaticSpeechRecognitionTask = class extends FalAITask {
+  prepareHeaders(params, binary) {
+    const headers = super.prepareHeaders(params, binary);
+    headers["Content-Type"] = "application/json";
+    return headers;
   }
-};
-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;
+    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)}`
+      );
     }
-    throw new InferenceOutputError("Expected Array<{answer: string, end: number, score: number, start: number}>");
+    return { text: res.text };
   }
 };
-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}>"
-    );
+var FalAITextToSpeechTask = class extends FalAITask {
+  preparePayload(params) {
+    return {
+      ...omit(params.args, ["inputs", "parameters"]),
+      ...params.args.parameters,
+      text: params.args.inputs
+    };
   }
-};
-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;
+    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)}`
+      );
     }
-    throw new InferenceOutputError("Expected Array<{labels: string[], scores: number[], sequence: string}>");
-  }
-};
-var HFInferenceSentenceSimilarityTask = class extends HFInferenceTask {
-  async getResponse(response) {
-    if (Array.isArray(response) && response.every((x) => typeof x === "number")) {
-      return response;
+    try {
+      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(
+        `Error fetching or processing audio from Fal.ai Text-to-Speech URL: ${res.audio.url}. ${error instanceof Error ? error.message : String(error)}`
+      );
     }
-    throw new InferenceOutputError("Expected Array<number>");
   }
 };
-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[][]}"
-    );
+
+// src/providers/featherless-ai.ts
+var FEATHERLESS_API_BASE_URL = "https://api.featherless.ai";
+var FeatherlessAIConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("featherless-ai", FEATHERLESS_API_BASE_URL);
   }
 };
-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}>"
-    );
+var FeatherlessAITextGenerationTask = class extends BaseTextGenerationTask {
+  constructor() {
+    super("featherless-ai", FEATHERLESS_API_BASE_URL);
   }
-};
-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}>");
+  preparePayload(params) {
+    return {
+      ...params.args,
+      ...params.args.parameters,
+      model: params.model,
+      prompt: params.args.inputs
+    };
   }
-};
-var HFInferenceSummarizationTask = class extends HFInferenceTask {
   async getResponse(response) {
-    if (Array.isArray(response) && response.every((x) => typeof x?.summary_text === "string")) {
-      return response?.[0];
+    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 Array<{summary_text: string}>");
+    throw new InferenceOutputError("Expected Featherless AI text generation response format");
   }
 };
-var HFInferenceTextToSpeechTask = class extends HFInferenceTask {
-  async getResponse(response) {
-    return response;
+
+// src/providers/fireworks-ai.ts
+var FireworksConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("fireworks-ai", "https://api.fireworks.ai");
   }
-};
-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>");
+  makeRoute() {
+    return "/inference/v1/chat/completions";
   }
 };
-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}>");
+
+// src/providers/groq.ts
+var GROQ_API_BASE_URL = "https://api.groq.com";
+var GroqTextGenerationTask = class extends BaseTextGenerationTask {
+  constructor() {
+    super("groq", GROQ_API_BASE_URL);
   }
-};
-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>");
+  makeRoute() {
+    return "/openai/v1/chat/completions";
   }
 };
-var HFInferenceTextToAudioTask = class extends HFInferenceTask {
-  async getResponse(response) {
-    return response;
+var GroqConversationalTask = class extends BaseConversationalTask {
+  constructor() {
+    super("groq", GROQ_API_BASE_URL);
+  }
+  makeRoute() {
+    return "/openai/v1/chat/completions";
   }
 };
 
@@ -1295,82 +1400,13 @@ function getProviderHelper(provider, task) {
 
 // package.json
 var name = "@huggingface/inference";
-var version = "3.10.0";
-
-// src/providers/consts.ts
-var HARDCODED_MODEL_INFERENCE_MAPPING = {
-  /**
-   * "HF model ID" => "Model ID on Inference Provider's side"
-   *
-   * Example:
-   * "Qwen/Qwen2.5-Coder-32B-Instruct": "Qwen2.5-Coder-32B-Instruct",
-   */
-  "black-forest-labs": {},
-  cerebras: {},
-  cohere: {},
-  "fal-ai": {},
-  "featherless-ai": {},
-  "fireworks-ai": {},
-  groq: {},
-  "hf-inference": {},
-  hyperbolic: {},
-  nebius: {},
-  novita: {},
-  nscale: {},
-  openai: {},
-  ovhcloud: {},
-  replicate: {},
-  sambanova: {},
-  together: {}
-};
-
-// src/lib/getInferenceProviderMapping.ts
-var inferenceProviderMappingCache = /* @__PURE__ */ new Map();
-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.modelId)) {
-    inferenceProviderMapping = inferenceProviderMappingCache.get(params.modelId);
-  } else {
-    const resp = await (options?.fetch ?? fetch)(
-      `${HF_HUB_URL}/api/models/${params.modelId}?expand[]=inferenceProviderMapping`,
-      {
-        headers: params.accessToken?.startsWith("hf_") ? { Authorization: `Bearer ${params.accessToken}` } : {}
-      }
-    );
-    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.modelId}.`);
-  }
-  const providerMapping = inferenceProviderMapping[params.provider];
-  if (providerMapping) {
-    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.modelId} is not supported for task ${params.task} and provider ${params.provider}. Supported task: ${providerMapping.task}.`
-      );
-    }
-    if (providerMapping.status === "staging") {
-      console.warn(
-        `Model ${params.modelId} is in staging mode for provider ${params.provider}. Meant for test purposes only.`
-      );
-    }
-    return { ...providerMapping, hfModelId: params.modelId };
-  }
-  return null;
-}
+var version = "3.12.0";
 
 // src/lib/makeRequestOptions.ts
 var tasks = null;
 async function makeRequestOptions(args, providerHelper, options) {
-  const { provider: maybeProvider, model: maybeModel } = args;
-  const provider = maybeProvider ?? "hf-inference";
+  const { model: maybeModel } = args;
+  const provider = providerHelper.provider;
   const { task } = options ?? {};
   if (args.endpointUrl && provider !== "hf-inference") {
     throw new Error(`Cannot use endpointUrl with a third-party provider.`);
@@ -1425,7 +1461,7 @@ async function makeRequestOptions(args, providerHelper, options) {
 }
 function makeRequestOptionsFromResolvedModel(resolvedModel, providerHelper, args, mapping, options) {
   const { accessToken, endpointUrl, provider: maybeProvider, model, ...remainingArgs } = args;
-  const provider = maybeProvider ?? "hf-inference";
+  const provider = providerHelper.provider;
   const { includeCredentials, task, signal, billTo } = options ?? {};
   const authMethod = (() => {
     if (providerHelper.clientSideRoutingOnly) {
@@ -1716,7 +1752,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 providerHelper = getProviderHelper(args.provider ?? "hf-inference", options?.task);
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, options?.task);
   const result = await innerRequest(args, providerHelper, options);
   return result.data;
 }
@@ -1726,7 +1763,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."
   );
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", options?.task);
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, options?.task);
   yield* innerStreamingRequest(args, providerHelper, options);
 }
 
@@ -1740,7 +1778,8 @@ function preparePayload(args) {
 
 // src/tasks/audio/audioClassification.ts
 async function audioClassification(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "audio-classification");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "audio-classification");
   const payload = preparePayload(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1751,7 +1790,9 @@ async function audioClassification(args, options) {
 
 // src/tasks/audio/audioToAudio.ts
 async function audioToAudio(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "audio-to-audio");
+  const model = "inputs" in args ? args.model : void 0;
+  const provider = await resolveProvider(args.provider, model);
+  const providerHelper = getProviderHelper(provider, "audio-to-audio");
   const payload = preparePayload(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1775,7 +1816,8 @@ function base64FromBytes(arr) {
 
 // src/tasks/audio/automaticSpeechRecognition.ts
 async function automaticSpeechRecognition(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "automatic-speech-recognition");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "automatic-speech-recognition");
   const payload = await buildPayload(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1815,7 +1857,7 @@ async function buildPayload(args) {
 
 // src/tasks/audio/textToSpeech.ts
 async function textToSpeech(args, options) {
-  const provider = args.provider ?? "hf-inference";
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
   const providerHelper = getProviderHelper(provider, "text-to-speech");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
@@ -1831,7 +1873,8 @@ function preparePayload2(args) {
 
 // src/tasks/cv/imageClassification.ts
 async function imageClassification(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-classification");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "image-classification");
   const payload = preparePayload2(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1842,7 +1885,8 @@ async function imageClassification(args, options) {
 
 // src/tasks/cv/imageSegmentation.ts
 async function imageSegmentation(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-segmentation");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "image-segmentation");
   const payload = preparePayload2(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1853,7 +1897,8 @@ async function imageSegmentation(args, options) {
 
 // src/tasks/cv/imageToImage.ts
 async function imageToImage(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-to-image");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "image-to-image");
   let reqArgs;
   if (!args.parameters) {
     reqArgs = {
@@ -1878,7 +1923,8 @@ async function imageToImage(args, options) {
 
 // src/tasks/cv/imageToText.ts
 async function imageToText(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "image-to-text");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "image-to-text");
   const payload = preparePayload2(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1889,7 +1935,8 @@ async function imageToText(args, options) {
 
 // src/tasks/cv/objectDetection.ts
 async function objectDetection(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "object-detection");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "object-detection");
   const payload = preparePayload2(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1900,7 +1947,7 @@ async function objectDetection(args, options) {
 
 // src/tasks/cv/textToImage.ts
 async function textToImage(args, options) {
-  const provider = args.provider ?? "hf-inference";
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
   const providerHelper = getProviderHelper(provider, "text-to-image");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
@@ -1912,7 +1959,7 @@ async function textToImage(args, options) {
 
 // src/tasks/cv/textToVideo.ts
 async function textToVideo(args, options) {
-  const provider = args.provider ?? "hf-inference";
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
   const providerHelper = getProviderHelper(provider, "text-to-video");
   const { data: response } = await innerRequest(
     args,
@@ -1949,7 +1996,8 @@ async function preparePayload3(args) {
   }
 }
 async function zeroShotImageClassification(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "zero-shot-image-classification");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "zero-shot-image-classification");
   const payload = await preparePayload3(args);
   const { data: res } = await innerRequest(payload, providerHelper, {
     ...options,
@@ -1960,7 +2008,8 @@ async function zeroShotImageClassification(args, options) {
 
 // src/tasks/nlp/chatCompletion.ts
 async function chatCompletion(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "conversational");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "conversational");
   const { data: response } = await innerRequest(args, providerHelper, {
     ...options,
     task: "conversational"
@@ -1970,7 +2019,8 @@ async function chatCompletion(args, options) {
 
 // src/tasks/nlp/chatCompletionStream.ts
 async function* chatCompletionStream(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "conversational");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "conversational");
   yield* innerStreamingRequest(args, providerHelper, {
     ...options,
     task: "conversational"
@@ -1979,7 +2029,8 @@ async function* chatCompletionStream(args, options) {
 
 // src/tasks/nlp/featureExtraction.ts
 async function featureExtraction(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "feature-extraction");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "feature-extraction");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "feature-extraction"
@@ -1989,7 +2040,8 @@ async function featureExtraction(args, options) {
 
 // src/tasks/nlp/fillMask.ts
 async function fillMask(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "fill-mask");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "fill-mask");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "fill-mask"
@@ -1999,7 +2051,8 @@ async function fillMask(args, options) {
 
 // src/tasks/nlp/questionAnswering.ts
 async function questionAnswering(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "question-answering");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "question-answering");
   const { data: res } = await innerRequest(
     args,
     providerHelper,
@@ -2013,7 +2066,8 @@ async function questionAnswering(args, options) {
 
 // src/tasks/nlp/sentenceSimilarity.ts
 async function sentenceSimilarity(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "sentence-similarity");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "sentence-similarity");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "sentence-similarity"
@@ -2023,7 +2077,8 @@ async function sentenceSimilarity(args, options) {
 
 // src/tasks/nlp/summarization.ts
 async function summarization(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "summarization");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "summarization");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "summarization"
@@ -2033,7 +2088,8 @@ async function summarization(args, options) {
 
 // src/tasks/nlp/tableQuestionAnswering.ts
 async function tableQuestionAnswering(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "table-question-answering");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "table-question-answering");
   const { data: res } = await innerRequest(
     args,
     providerHelper,
@@ -2047,7 +2103,8 @@ async function tableQuestionAnswering(args, options) {
 
 // src/tasks/nlp/textClassification.ts
 async function textClassification(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-classification");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "text-classification");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "text-classification"
@@ -2057,7 +2114,8 @@ async function textClassification(args, options) {
 
 // src/tasks/nlp/textGeneration.ts
 async function textGeneration(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-generation");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "text-generation");
   const { data: response } = await innerRequest(args, providerHelper, {
     ...options,
     task: "text-generation"
@@ -2067,7 +2125,8 @@ async function textGeneration(args, options) {
 
 // src/tasks/nlp/textGenerationStream.ts
 async function* textGenerationStream(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "text-generation");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "text-generation");
   yield* innerStreamingRequest(args, providerHelper, {
     ...options,
     task: "text-generation"
@@ -2076,7 +2135,8 @@ async function* textGenerationStream(args, options) {
 
 // src/tasks/nlp/tokenClassification.ts
 async function tokenClassification(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "token-classification");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "token-classification");
   const { data: res } = await innerRequest(
     args,
     providerHelper,
@@ -2090,7 +2150,8 @@ async function tokenClassification(args, options) {
 
 // src/tasks/nlp/translation.ts
 async function translation(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "translation");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "translation");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "translation"
@@ -2100,7 +2161,8 @@ async function translation(args, options) {
 
 // src/tasks/nlp/zeroShotClassification.ts
 async function zeroShotClassification(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "zero-shot-classification");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "zero-shot-classification");
   const { data: res } = await innerRequest(
     args,
     providerHelper,
@@ -2114,7 +2176,8 @@ async function zeroShotClassification(args, options) {
 
 // src/tasks/multimodal/documentQuestionAnswering.ts
 async function documentQuestionAnswering(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "document-question-answering");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "document-question-answering");
   const reqArgs = {
     ...args,
     inputs: {
@@ -2136,7 +2199,8 @@ async function documentQuestionAnswering(args, options) {
 
 // src/tasks/multimodal/visualQuestionAnswering.ts
 async function visualQuestionAnswering(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "visual-question-answering");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "visual-question-answering");
   const reqArgs = {
     ...args,
     inputs: {
@@ -2154,7 +2218,8 @@ async function visualQuestionAnswering(args, options) {
 
 // src/tasks/tabular/tabularClassification.ts
 async function tabularClassification(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-classification");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "tabular-classification");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "tabular-classification"
@@ -2164,7 +2229,8 @@ async function tabularClassification(args, options) {
 
 // src/tasks/tabular/tabularRegression.ts
 async function tabularRegression(args, options) {
-  const providerHelper = getProviderHelper(args.provider ?? "hf-inference", "tabular-regression");
+  const provider = await resolveProvider(args.provider, args.model, args.endpointUrl);
+  const providerHelper = getProviderHelper(provider, "tabular-regression");
   const { data: res } = await innerRequest(args, providerHelper, {
     ...options,
     task: "tabular-regression"
@@ -2172,6 +2238,11 @@ async function tabularRegression(args, options) {
   return providerHelper.getResponse(res);
 }
 
+// src/utils/typedEntries.ts
+function typedEntries(obj) {
+  return Object.entries(obj);
+}
+
 // src/InferenceClient.ts
 var InferenceClient = class {
   accessToken;
@@ -2179,40 +2250,36 @@ var InferenceClient = class {
   constructor(accessToken = "", defaultOptions = {}) {
     this.accessToken = accessToken;
     this.defaultOptions = defaultOptions;
-    for (const [name2, fn] of Object.entries(tasks_exports)) {
+    for (const [name2, fn] of typedEntries(tasks_exports)) {
       Object.defineProperty(this, name2, {
         enumerable: false,
         value: (params, options) => (
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          fn({ ...params, accessToken }, { ...defaultOptions, ...options })
+          fn(
+            /// ^ The cast of fn to any is necessary, otherwise TS can't compile because the generated union type is too complex
+            { endpointUrl: defaultOptions.endpointUrl, accessToken, ...params },
+            {
+              ...omit(defaultOptions, ["endpointUrl"]),
+              ...options
+            }
+          )
         )
       });
     }
   }
   /**
-   * Returns copy of InferenceClient tied to a specified endpoint.
+   * Returns a new instance of InferenceClient tied to a specified endpoint.
+   *
+   * For backward compatibility mostly.
    */
   endpoint(endpointUrl) {
-    return new InferenceClientEndpoint(endpointUrl, this.accessToken, this.defaultOptions);
-  }
-};
-var InferenceClientEndpoint = class {
-  constructor(endpointUrl, accessToken = "", defaultOptions = {}) {
-    accessToken;
-    defaultOptions;
-    for (const [name2, fn] of Object.entries(tasks_exports)) {
-      Object.defineProperty(this, name2, {
-        enumerable: false,
-        value: (params, options) => (
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          fn({ ...params, accessToken, endpointUrl }, { ...defaultOptions, ...options })
-        )
-      });
-    }
+    return new InferenceClient(this.accessToken, { ...this.defaultOptions, endpointUrl });
   }
 };
 var HfInference = class extends InferenceClient {
 };
+var InferenceClientEndpoint = class extends InferenceClient {
+};
 
 // src/types.ts
 var INFERENCE_PROVIDERS = [
@@ -2234,6 +2301,7 @@ var INFERENCE_PROVIDERS = [
   "sambanova",
   "together"
 ];
+var PROVIDERS_OR_POLICIES = [...INFERENCE_PROVIDERS, "auto"];
 
 // src/snippets/index.ts
 var snippets_exports = {};
@@ -2565,7 +2633,7 @@ var prepareConversationalInput = (model, opts) => {
   return {
     messages: opts?.messages ?? getModelInputSnippet(model),
     ...opts?.temperature ? { temperature: opts?.temperature } : void 0,
-    max_tokens: opts?.max_tokens ?? 512,
+    ...opts?.max_tokens ? { max_tokens: opts?.max_tokens } : void 0,
     ...opts?.top_p ? { top_p: opts?.top_p } : void 0
   };
 };
@@ -2658,6 +2726,7 @@ export {
   InferenceClient,
   InferenceClientEndpoint,
   InferenceOutputError,
+  PROVIDERS_OR_POLICIES,
   audioClassification,
   audioToAudio,
   automaticSpeechRecognition,