@huggingface/inference 2.8.0 → 3.0.0

package/dist/index.cjs

@@ -20,9 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  FAL_AI_SUPPORTED_MODEL_IDS: () => FAL_AI_SUPPORTED_MODEL_IDS,
   HfInference: () => HfInference,
   HfInferenceEndpoint: () => HfInferenceEndpoint,
+  INFERENCE_PROVIDERS: () => INFERENCE_PROVIDERS,
   InferenceOutputError: () => InferenceOutputError,
+  REPLICATE_SUPPORTED_MODEL_IDS: () => REPLICATE_SUPPORTED_MODEL_IDS,
+  SAMBANOVA_SUPPORTED_MODEL_IDS: () => SAMBANOVA_SUPPORTED_MODEL_IDS,
+  TOGETHER_SUPPORTED_MODEL_IDS: () => TOGETHER_SUPPORTED_MODEL_IDS,
   audioClassification: () => audioClassification,
   audioToAudio: () => audioToAudio,
   automaticSpeechRecognition: () => automaticSpeechRecognition,
@@ -93,131 +98,164 @@ __export(tasks_exports, {
   zeroShotImageClassification: () => zeroShotImageClassification
 });
 
-// src/utils/pick.ts
-function pick(o, props) {
-  return Object.assign(
-    {},
-    ...props.map((prop) => {
-      if (o[prop] !== void 0) {
-        return { [prop]: o[prop] };
-      }
-    })
-  );
-}
+// src/config.ts
+var HF_HUB_URL = "https://huggingface.co";
+var HF_INFERENCE_API_URL = "https://api-inference.huggingface.co";
 
-// src/utils/typedInclude.ts
-function typedInclude(arr, v) {
-  return arr.includes(v);
-}
+// src/providers/fal-ai.ts
+var FAL_AI_API_BASE_URL = "https://fal.run";
+var FAL_AI_SUPPORTED_MODEL_IDS = {
+  "text-to-image": {
+    "black-forest-labs/FLUX.1-schnell": "fal-ai/flux/schnell",
+    "black-forest-labs/FLUX.1-dev": "fal-ai/flux/dev"
+  },
+  "automatic-speech-recognition": {
+    "openai/whisper-large-v3": "fal-ai/whisper"
+  }
+};
 
-// 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/replicate.ts
+var REPLICATE_API_BASE_URL = "https://api.replicate.com";
+var REPLICATE_SUPPORTED_MODEL_IDS = {
+  "text-to-image": {
+    "black-forest-labs/FLUX.1-schnell": "black-forest-labs/flux-schnell",
+    "ByteDance/SDXL-Lightning": "bytedance/sdxl-lightning-4step:5599ed30703defd1d160a25a63321b4dec97101d98b4674bcc56e41f62f35637"
+  }
+  // "text-to-speech": {
+  // 	"SWivid/F5-TTS": "x-lance/f5-tts:87faf6dd7a692dd82043f662e76369cab126a2cf1937e25a9d41e0b834fd230e"
+  // },
+};
+
+// src/providers/sambanova.ts
+var SAMBANOVA_API_BASE_URL = "https://api.sambanova.ai";
+var SAMBANOVA_SUPPORTED_MODEL_IDS = {
+  /** Chat completion / conversational */
+  conversational: {
+    "Qwen/Qwen2.5-Coder-32B-Instruct": "Qwen2.5-Coder-32B-Instruct",
+    "Qwen/Qwen2.5-72B-Instruct": "Qwen2.5-72B-Instruct",
+    "Qwen/QwQ-32B-Preview": "QwQ-32B-Preview",
+    "meta-llama/Llama-3.3-70B-Instruct": "Meta-Llama-3.3-70B-Instruct",
+    "meta-llama/Llama-3.2-1B-Instruct": "Meta-Llama-3.2-1B-Instruct",
+    "meta-llama/Llama-3.2-3B-Instruct": "Meta-Llama-3.2-3B-Instruct",
+    "meta-llama/Llama-3.2-11B-Vision-Instruct": "Llama-3.2-11B-Vision-Instruct",
+    "meta-llama/Llama-3.2-90B-Vision-Instruct": "Llama-3.2-90B-Vision-Instruct",
+    "meta-llama/Llama-3.1-8B-Instruct": "Meta-Llama-3.1-8B-Instruct",
+    "meta-llama/Llama-3.1-70B-Instruct": "Meta-Llama-3.1-70B-Instruct",
+    "meta-llama/Llama-3.1-405B-Instruct": "Meta-Llama-3.1-405B-Instruct",
+    "meta-llama/Llama-Guard-3-8B": "Meta-Llama-Guard-3-8B"
+  }
+};
+
+// src/providers/together.ts
+var TOGETHER_API_BASE_URL = "https://api.together.xyz";
+var TOGETHER_SUPPORTED_MODEL_IDS = {
+  "text-to-image": {
+    "black-forest-labs/FLUX.1-Canny-dev": "black-forest-labs/FLUX.1-canny",
+    "black-forest-labs/FLUX.1-Depth-dev": "black-forest-labs/FLUX.1-depth",
+    "black-forest-labs/FLUX.1-dev": "black-forest-labs/FLUX.1-dev",
+    "black-forest-labs/FLUX.1-Redux-dev": "black-forest-labs/FLUX.1-redux",
+    "black-forest-labs/FLUX.1-schnell": "black-forest-labs/FLUX.1-pro",
+    "stabilityai/stable-diffusion-xl-base-1.0": "stabilityai/stable-diffusion-xl-base-1.0"
+  },
+  conversational: {
+    "databricks/dbrx-instruct": "databricks/dbrx-instruct",
+    "deepseek-ai/deepseek-llm-67b-chat": "deepseek-ai/deepseek-llm-67b-chat",
+    "google/gemma-2-9b-it": "google/gemma-2-9b-it",
+    "google/gemma-2b-it": "google/gemma-2-27b-it",
+    "llava-hf/llava-v1.6-mistral-7b-hf": "llava-hf/llava-v1.6-mistral-7b-hf",
+    "meta-llama/Llama-2-13b-chat-hf": "meta-llama/Llama-2-13b-chat-hf",
+    "meta-llama/Llama-2-70b-hf": "meta-llama/Llama-2-70b-hf",
+    "meta-llama/Llama-2-7b-chat-hf": "meta-llama/Llama-2-7b-chat-hf",
+    "meta-llama/Llama-3.2-11B-Vision-Instruct": "meta-llama/Llama-Vision-Free",
+    "meta-llama/Llama-3.2-3B-Instruct": "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+    "meta-llama/Llama-3.2-90B-Vision-Instruct": "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo",
+    "meta-llama/Llama-3.3-70B-Instruct": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    "meta-llama/Meta-Llama-3-70B-Instruct": "meta-llama/Llama-3-70b-chat-hf",
+    "meta-llama/Meta-Llama-3-8B-Instruct": "togethercomputer/Llama-3-8b-chat-hf-int4",
+    "meta-llama/Meta-Llama-3.1-405B-Instruct": "meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
+    "meta-llama/Meta-Llama-3.1-70B-Instruct": "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+    "meta-llama/Meta-Llama-3.1-8B-Instruct": "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo-128K",
+    "microsoft/WizardLM-2-8x22B": "microsoft/WizardLM-2-8x22B",
+    "mistralai/Mistral-7B-Instruct-v0.3": "mistralai/Mistral-7B-Instruct-v0.3",
+    "mistralai/Mixtral-8x22B-Instruct-v0.1": "mistralai/Mixtral-8x22B-Instruct-v0.1",
+    "mistralai/Mixtral-8x7B-Instruct-v0.1": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO": "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+    "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF": "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
+    "Qwen/Qwen2-72B-Instruct": "Qwen/Qwen2-72B-Instruct",
+    "Qwen/Qwen2.5-72B-Instruct": "Qwen/Qwen2.5-72B-Instruct-Turbo",
+    "Qwen/Qwen2.5-7B-Instruct": "Qwen/Qwen2.5-7B-Instruct-Turbo",
+    "Qwen/Qwen2.5-Coder-32B-Instruct": "Qwen/Qwen2.5-Coder-32B-Instruct",
+    "Qwen/QwQ-32B-Preview": "Qwen/QwQ-32B-Preview",
+    "scb10x/llama-3-typhoon-v1.5-8b-instruct": "scb10x/scb10x-llama3-typhoon-v1-5-8b-instruct",
+    "scb10x/llama-3-typhoon-v1.5x-70b-instruct-awq": "scb10x/scb10x-llama3-typhoon-v1-5x-4f316"
+  },
+  "text-generation": {
+    "meta-llama/Meta-Llama-3-8B": "meta-llama/Meta-Llama-3-8B",
+    "mistralai/Mixtral-8x7B-v0.1": "mistralai/Mixtral-8x7B-v0.1"
+  }
+};
 
 // src/lib/isUrl.ts
 function isUrl(modelOrUrl) {
   return /^http(s?):/.test(modelOrUrl) || modelOrUrl.startsWith("/");
 }
 
-// src/lib/getDefaultTask.ts
-var taskCache = /* @__PURE__ */ new Map();
-var CACHE_DURATION = 10 * 60 * 1e3;
-var MAX_CACHE_ITEMS = 1e3;
-var HF_HUB_URL = "https://huggingface.co";
-async function getDefaultTask(model, accessToken, options) {
-  if (isUrl(model)) {
-    return null;
-  }
-  const key = `${model}:${accessToken}`;
-  let cachedTask = taskCache.get(key);
-  if (cachedTask && cachedTask.date < new Date(Date.now() - CACHE_DURATION)) {
-    taskCache.delete(key);
-    cachedTask = void 0;
-  }
-  if (cachedTask === void 0) {
-    const modelTask = await (options?.fetch ?? fetch)(`${HF_HUB_URL}/api/models/${model}?expand[]=pipeline_tag`, {
-      headers: accessToken ? { Authorization: `Bearer ${accessToken}` } : {}
-    }).then((resp) => resp.json()).then((json) => json.pipeline_tag).catch(() => null);
-    if (!modelTask) {
-      return null;
-    }
-    cachedTask = { task: modelTask, date: /* @__PURE__ */ new Date() };
-    taskCache.set(key, { task: modelTask, date: /* @__PURE__ */ new Date() });
-    if (taskCache.size > MAX_CACHE_ITEMS) {
-      taskCache.delete(taskCache.keys().next().value);
-    }
-  }
-  return cachedTask.task;
-}
-
 // src/lib/makeRequestOptions.ts
-var HF_INFERENCE_API_BASE_URL = "https://api-inference.huggingface.co";
+var HF_HUB_INFERENCE_PROXY_TEMPLATE = `${HF_HUB_URL}/api/inference-proxy/{{PROVIDER}}`;
 var tasks = null;
 async function makeRequestOptions(args, options) {
-  const { accessToken, endpointUrl, ...otherArgs } = args;
-  let { model } = args;
-  const {
-    forceTask: task,
-    includeCredentials,
-    taskHint,
-    wait_for_model,
-    use_cache,
-    dont_load_model,
-    chatCompletion: chatCompletion2
-  } = options ?? {};
-  const headers = {};
-  if (accessToken) {
-    headers["Authorization"] = `Bearer ${accessToken}`;
+  const { accessToken, endpointUrl, provider: maybeProvider, model: maybeModel, ...otherArgs } = args;
+  const provider = maybeProvider ?? "hf-inference";
+  const { forceTask, includeCredentials, taskHint, wait_for_model, use_cache, dont_load_model, chatCompletion: chatCompletion2 } = options ?? {};
+  if (endpointUrl && provider !== "hf-inference") {
+    throw new Error(`Cannot use endpointUrl with a third-party provider.`);
   }
-  if (!model && !tasks && taskHint) {
-    const res = await fetch(`${HF_HUB_URL}/api/tasks`);
-    if (res.ok) {
-      tasks = await res.json();
-    }
+  if (forceTask && provider !== "hf-inference") {
+    throw new Error(`Cannot use forceTask with a third-party provider.`);
+  }
+  if (maybeModel && isUrl(maybeModel)) {
+    throw new Error(`Model URLs are no longer supported. Use endpointUrl instead.`);
   }
-  if (!model && tasks && taskHint) {
-    const taskInfo = tasks[taskHint];
-    if (taskInfo) {
-      model = taskInfo.models[0].id;
+  let model;
+  if (!maybeModel) {
+    if (taskHint) {
+      model = mapModel({ model: await loadDefaultModel(taskHint), provider, taskHint, chatCompletion: chatCompletion2 });
+    } else {
+      throw new Error("No model provided, and no default model found for this task");
     }
+  } else {
+    model = mapModel({ model: maybeModel, provider, taskHint, chatCompletion: chatCompletion2 });
   }
-  if (!model) {
-    throw new Error("No model provided, and no default model found for this task");
+  const authMethod = accessToken ? accessToken.startsWith("hf_") ? "hf-token" : "provider-key" : includeCredentials === "include" ? "credentials-include" : "none";
+  const url = endpointUrl ? chatCompletion2 ? endpointUrl + `/v1/chat/completions` : endpointUrl : makeUrl({
+    authMethod,
+    chatCompletion: chatCompletion2 ?? false,
+    forceTask,
+    model,
+    provider: provider ?? "hf-inference",
+    taskHint
+  });
+  const headers = {};
+  if (accessToken) {
+    headers["Authorization"] = provider === "fal-ai" && authMethod === "provider-key" ? `Key ${accessToken}` : `Bearer ${accessToken}`;
   }
   const binary = "data" in args && !!args.data;
   if (!binary) {
     headers["Content-Type"] = "application/json";
   }
-  if (wait_for_model) {
-    headers["X-Wait-For-Model"] = "true";
-  }
-  if (use_cache === false) {
-    headers["X-Use-Cache"] = "false";
-  }
-  if (dont_load_model) {
-    headers["X-Load-Model"] = "0";
-  }
-  let url = (() => {
-    if (endpointUrl && isUrl(model)) {
-      throw new TypeError("Both model and endpointUrl cannot be URLs");
-    }
-    if (isUrl(model)) {
-      console.warn("Using a model URL is deprecated, please use the `endpointUrl` parameter instead");
-      return model;
+  if (provider === "hf-inference") {
+    if (wait_for_model) {
+      headers["X-Wait-For-Model"] = "true";
     }
-    if (endpointUrl) {
-      return endpointUrl;
+    if (use_cache === false) {
+      headers["X-Use-Cache"] = "false";
     }
-    if (task) {
-      return `${HF_INFERENCE_API_BASE_URL}/pipeline/${task}/${model}`;
+    if (dont_load_model) {
+      headers["X-Load-Model"] = "0";
     }
-    return `${HF_INFERENCE_API_BASE_URL}/models/${model}`;
-  })();
-  if (chatCompletion2 && !url.endsWith("/chat/completions")) {
-    url += "/v1/chat/completions";
+  }
+  if (provider === "replicate") {
+    headers["Prefer"] = "wait";
   }
   let credentials;
   if (typeof includeCredentials === "string") {
@@ -225,17 +263,110 @@ async function makeRequestOptions(args, options) {
   } else if (includeCredentials === true) {
     credentials = "include";
   }
+  if (provider === "replicate" && model.includes(":")) {
+    const version = model.split(":")[1];
+    otherArgs.version = version;
+  }
   const info = {
     headers,
     method: "POST",
     body: binary ? args.data : JSON.stringify({
-      ...otherArgs.model && isUrl(otherArgs.model) ? omit(otherArgs, "model") : otherArgs
+      ...otherArgs,
+      ...chatCompletion2 || provider === "together" ? { model } : void 0
     }),
-    ...credentials && { credentials },
+    ...credentials ? { credentials } : void 0,
     signal: options?.signal
   };
   return { url, info };
 }
+function mapModel(params) {
+  if (params.provider === "hf-inference") {
+    return params.model;
+  }
+  if (!params.taskHint) {
+    throw new Error("taskHint must be specified when using a third-party provider");
+  }
+  const task = params.taskHint === "text-generation" && params.chatCompletion ? "conversational" : params.taskHint;
+  const model = (() => {
+    switch (params.provider) {
+      case "fal-ai":
+        return FAL_AI_SUPPORTED_MODEL_IDS[task]?.[params.model];
+      case "replicate":
+        return REPLICATE_SUPPORTED_MODEL_IDS[task]?.[params.model];
+      case "sambanova":
+        return SAMBANOVA_SUPPORTED_MODEL_IDS[task]?.[params.model];
+      case "together":
+        return TOGETHER_SUPPORTED_MODEL_IDS[task]?.[params.model];
+    }
+  })();
+  if (!model) {
+    throw new Error(`Model ${params.model} is not supported for task ${task} and provider ${params.provider}`);
+  }
+  return model;
+}
+function makeUrl(params) {
+  if (params.authMethod === "none" && params.provider !== "hf-inference") {
+    throw new Error("Authentication is required when requesting a third-party provider. Please provide accessToken");
+  }
+  const shouldProxy = params.provider !== "hf-inference" && params.authMethod !== "provider-key";
+  switch (params.provider) {
+    case "fal-ai": {
+      const baseUrl = shouldProxy ? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider) : FAL_AI_API_BASE_URL;
+      return `${baseUrl}/${params.model}`;
+    }
+    case "replicate": {
+      const baseUrl = shouldProxy ? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider) : REPLICATE_API_BASE_URL;
+      if (params.model.includes(":")) {
+        return `${baseUrl}/v1/predictions`;
+      }
+      return `${baseUrl}/v1/models/${params.model}/predictions`;
+    }
+    case "sambanova": {
+      const baseUrl = shouldProxy ? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider) : SAMBANOVA_API_BASE_URL;
+      if (params.taskHint === "text-generation" && params.chatCompletion) {
+        return `${baseUrl}/v1/chat/completions`;
+      }
+      return baseUrl;
+    }
+    case "together": {
+      const baseUrl = shouldProxy ? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", params.provider) : TOGETHER_API_BASE_URL;
+      if (params.taskHint === "text-to-image") {
+        return `${baseUrl}/v1/images/generations`;
+      }
+      if (params.taskHint === "text-generation") {
+        if (params.chatCompletion) {
+          return `${baseUrl}/v1/chat/completions`;
+        }
+        return `${baseUrl}/v1/completions`;
+      }
+      return baseUrl;
+    }
+    default: {
+      const url = params.forceTask ? `${HF_INFERENCE_API_URL}/pipeline/${params.forceTask}/${params.model}` : `${HF_INFERENCE_API_URL}/models/${params.model}`;
+      if (params.taskHint === "text-generation" && params.chatCompletion) {
+        return url + `/v1/chat/completions`;
+      }
+      return url;
+    }
+  }
+}
+async function loadDefaultModel(task) {
+  if (!tasks) {
+    tasks = await loadTaskInfo();
+  }
+  const taskInfo = tasks[task];
+  if ((taskInfo?.models.length ?? 0) <= 0) {
+    throw new Error(`No default model defined for task ${task}, please define the model explicitly.`);
+  }
+  return taskInfo.models[0].id;
+}
+async function loadTaskInfo() {
+  const res = await fetch(`${HF_HUB_URL}/api/tasks`);
+  if (!res.ok) {
+    throw new Error("Failed to load tasks definitions from Hugging Face Hub.");
+  }
+  return await res.json();
+}
 
 // src/tasks/custom/request.ts
 async function request(args, options) {
@@ -248,16 +379,22 @@ async function request(args, options) {
     });
   }
   if (!response.ok) {
-    if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+    const contentType = response.headers.get("Content-Type");
+    if (["application/json", "application/problem+json"].some((ct) => contentType?.startsWith(ct))) {
       const output = await response.json();
       if ([400, 422, 404, 500].includes(response.status) && options?.chatCompletion) {
-        throw new Error(`Server ${args.model} does not seem to support chat completion. Error: ${output.error}`);
+        throw new Error(
+          `Server ${args.model} does not seem to support chat completion. Error: ${JSON.stringify(output.error)}`
+        );
       }
-      if (output.error) {
-        throw new Error(output.error);
+      if (output.error || output.detail) {
+        throw new Error(JSON.stringify(output.error ?? output.detail));
+      } else {
+        throw new Error(output);
       }
     }
-    throw new Error("An error occurred while fetching the blob");
+    const message = contentType?.startsWith("text/plain;") ? await response.text() : void 0;
+    throw new Error(message ?? "An error occurred while fetching the blob");
   }
   if (response.headers.get("Content-Type")?.startsWith("application/json")) {
     return await response.json();
@@ -380,9 +517,12 @@ async function* streamingRequest(args, options) {
       if ([400, 422, 404, 500].includes(response.status) && options?.chatCompletion) {
         throw new Error(`Server ${args.model} does not seem to support chat completion. Error: ${output.error}`);
       }
-      if (output.error) {
+      if (typeof output.error === "string") {
         throw new Error(output.error);
       }
+      if (output.error && "message" in output.error && typeof output.error.message === "string") {
+        throw new Error(output.error.message);
+      }
     }
     throw new Error(`Server response contains error: ${response.status}`);
   }
@@ -411,8 +551,9 @@ async function* streamingRequest(args, options) {
   try {
     while (true) {
       const { done, value } = await reader.read();
-      if (done)
+      if (done) {
         return;
+      }
       onChunk(value);
       for (const event of events) {
         if (event.data.length > 0) {
@@ -421,7 +562,8 @@ async function* streamingRequest(args, options) {
           }
           const data = JSON.parse(event.data);
           if (typeof data === "object" && data !== null && "error" in data) {
-            throw new Error(data.error);
+            const errorStr = typeof data.error === "string" ? data.error : typeof data.error === "object" && data.error && "message" in data.error && typeof data.error.message === "string" ? data.error.message : JSON.stringify(data.error);
+            throw new Error(`Error forwarded from backend: ` + errorStr);
           }
           yield data;
         }
@@ -456,8 +598,29 @@ async function audioClassification(args, options) {
   return res;
 }
 
+// src/utils/base64FromBytes.ts
+function base64FromBytes(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
 // src/tasks/audio/automaticSpeechRecognition.ts
 async function automaticSpeechRecognition(args, options) {
+  if (args.provider === "fal-ai") {
+    const contentType = args.data instanceof Blob ? args.data.type : "audio/mpeg";
+    const base64audio = base64FromBytes(
+      new Uint8Array(args.data instanceof ArrayBuffer ? args.data : await args.data.arrayBuffer())
+    );
+    args.audio_url = `data:${contentType};base64,${base64audio}`;
+    delete args.data;
+  }
   const res = await request(args, {
     ...options,
     taskHint: "automatic-speech-recognition"
@@ -554,10 +717,35 @@ async function objectDetection(args, options) {
 
 // src/tasks/cv/textToImage.ts
 async function textToImage(args, options) {
+  if (args.provider === "together" || args.provider === "fal-ai") {
+    args.prompt = args.inputs;
+    args.inputs = "";
+    args.response_format = "base64";
+  } else if (args.provider === "replicate") {
+    args.input = { prompt: args.inputs };
+    delete args.inputs;
+  }
   const res = await request(args, {
     ...options,
     taskHint: "text-to-image"
   });
+  if (res && typeof res === "object") {
+    if (args.provider === "fal-ai" && "images" in res && Array.isArray(res.images) && res.images[0].url) {
+      const image = await fetch(res.images[0].url);
+      return await image.blob();
+    }
+    if ("data" in res && Array.isArray(res.data) && res.data[0].b64_json) {
+      const base64Data = res.data[0].b64_json;
+      const base64Response = await fetch(`data:image/jpeg;base64,${base64Data}`);
+      const blob = await base64Response.blob();
+      return blob;
+    }
+    if ("output" in res && Array.isArray(res.output)) {
+      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");
@@ -565,19 +753,6 @@ async function textToImage(args, options) {
   return res;
 }
 
-// src/utils/base64FromBytes.ts
-function base64FromBytes(arr) {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
-  } else {
-    const bin = [];
-    arr.forEach((byte) => {
-      bin.push(String.fromCharCode(byte));
-    });
-    return globalThis.btoa(bin.join(""));
-  }
-}
-
 // src/tasks/cv/imageToImage.ts
 async function imageToImage(args, options) {
   let reqArgs;
@@ -629,6 +804,36 @@ async function zeroShotImageClassification(args, options) {
   return res;
 }
 
+// src/lib/getDefaultTask.ts
+var taskCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION = 10 * 60 * 1e3;
+var MAX_CACHE_ITEMS = 1e3;
+async function getDefaultTask(model, accessToken, options) {
+  if (isUrl(model)) {
+    return null;
+  }
+  const key = `${model}:${accessToken}`;
+  let cachedTask = taskCache.get(key);
+  if (cachedTask && cachedTask.date < new Date(Date.now() - CACHE_DURATION)) {
+    taskCache.delete(key);
+    cachedTask = void 0;
+  }
+  if (cachedTask === void 0) {
+    const modelTask = await (options?.fetch ?? fetch)(`${HF_HUB_URL}/api/models/${model}?expand[]=pipeline_tag`, {
+      headers: accessToken ? { Authorization: `Bearer ${accessToken}` } : {}
+    }).then((resp) => resp.json()).then((json) => json.pipeline_tag).catch(() => null);
+    if (!modelTask) {
+      return null;
+    }
+    cachedTask = { task: modelTask, date: /* @__PURE__ */ new Date() };
+    taskCache.set(key, { task: modelTask, date: /* @__PURE__ */ new Date() });
+    if (taskCache.size > MAX_CACHE_ITEMS) {
+      taskCache.delete(taskCache.keys().next().value);
+    }
+  }
+  return cachedTask.task;
+}
+
 // src/tasks/nlp/featureExtraction.ts
 async function featureExtraction(args, options) {
   const defaultTask = args.model ? await getDefaultTask(args.model, args.accessToken, options) : void 0;
@@ -750,17 +955,33 @@ function toArray(obj) {
 
 // src/tasks/nlp/textGeneration.ts
 async function textGeneration(args, options) {
-  const res = toArray(
-    await request(args, {
+  if (args.provider === "together") {
+    args.prompt = args.inputs;
+    const raw = await request(args, {
       ...options,
       taskHint: "text-generation"
-    })
-  );
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.generated_text === "string");
-  if (!isValidOutput) {
-    throw new InferenceOutputError("Expected Array<{generated_text: string}>");
+    });
+    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 {
+    const res = toArray(
+      await request(args, {
+        ...options,
+        taskHint: "text-generation"
+      })
+    );
+    const isValidOutput = Array.isArray(res) && res.every((x) => "generated_text" in x && typeof x?.generated_text === "string");
+    if (!isValidOutput) {
+      throw new InferenceOutputError("Expected Array<{generated_text: string}>");
+    }
+    return res?.[0];
   }
-  return res?.[0];
 }
 
 // src/tasks/nlp/textGenerationStream.ts
@@ -827,7 +1048,8 @@ async function chatCompletion(args, options) {
     taskHint: "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" && typeof res?.system_fingerprint === "string" && typeof res?.usage === "object";
+  const isValidOutput = typeof res === "object" && Array.isArray(res?.choices) && typeof res?.created === "number" && typeof res?.id === "string" && typeof res?.model === "string" && /// Together.ai does not output a system_fingerprint
+  (res.system_fingerprint === void 0 || typeof res.system_fingerprint === "string") && typeof res?.usage === "object";
   if (!isValidOutput) {
     throw new InferenceOutputError("Expected ChatCompletionOutput");
   }
@@ -960,11 +1182,19 @@ var HfInferenceEndpoint = class {
     }
   }
 };
+
+// src/types.ts
+var INFERENCE_PROVIDERS = ["fal-ai", "replicate", "sambanova", "together", "hf-inference"];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FAL_AI_SUPPORTED_MODEL_IDS,
   HfInference,
   HfInferenceEndpoint,
+  INFERENCE_PROVIDERS,
   InferenceOutputError,
+  REPLICATE_SUPPORTED_MODEL_IDS,
+  SAMBANOVA_SUPPORTED_MODEL_IDS,
+  TOGETHER_SUPPORTED_MODEL_IDS,
   audioClassification,
   audioToAudio,
   automaticSpeechRecognition,