@huggingface/inference 3.6.1 → 3.6.2

package/dist/index.cjs

@@ -104,6 +104,9 @@ var HF_ROUTER_URL = "https://router.huggingface.co";
 
 // src/providers/black-forest-labs.ts
 var BLACK_FOREST_LABS_AI_API_BASE_URL = "https://api.us1.bfl.ai";
+var makeBaseUrl = () => {
+  return BLACK_FOREST_LABS_AI_API_BASE_URL;
+};
 var makeBody = (params) => {
   return params.args;
 };
@@ -118,7 +121,7 @@ var makeUrl = (params) => {
   return `${params.baseUrl}/v1/${params.model}`;
 };
 var BLACK_FOREST_LABS_CONFIG = {
-  baseUrl: BLACK_FOREST_LABS_AI_API_BASE_URL,
+  makeBaseUrl,
   makeBody,
   makeHeaders,
   makeUrl
@@ -126,6 +129,9 @@ var BLACK_FOREST_LABS_CONFIG = {
 
 // src/providers/cerebras.ts
 var CEREBRAS_API_BASE_URL = "https://api.cerebras.ai";
+var makeBaseUrl2 = () => {
+  return CEREBRAS_API_BASE_URL;
+};
 var makeBody2 = (params) => {
   return {
     ...params.args,
@@ -139,7 +145,7 @@ var makeUrl2 = (params) => {
   return `${params.baseUrl}/v1/chat/completions`;
 };
 var CEREBRAS_CONFIG = {
-  baseUrl: CEREBRAS_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl2,
   makeBody: makeBody2,
   makeHeaders: makeHeaders2,
   makeUrl: makeUrl2
@@ -147,6 +153,9 @@ var CEREBRAS_CONFIG = {
 
 // src/providers/cohere.ts
 var COHERE_API_BASE_URL = "https://api.cohere.com";
+var makeBaseUrl3 = () => {
+  return COHERE_API_BASE_URL;
+};
 var makeBody3 = (params) => {
   return {
     ...params.args,
@@ -160,14 +169,40 @@ var makeUrl3 = (params) => {
   return `${params.baseUrl}/compatibility/v1/chat/completions`;
 };
 var COHERE_CONFIG = {
-  baseUrl: COHERE_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl3,
   makeBody: makeBody3,
   makeHeaders: makeHeaders3,
   makeUrl: makeUrl3
 };
 
+// src/lib/InferenceOutputError.ts
+var InferenceOutputError = class extends TypeError {
+  constructor(message) {
+    super(
+      `Invalid inference output: ${message}. Use the 'request' method with the same parameters to do a custom call with no type checking.`
+    );
+    this.name = "InferenceOutputError";
+  }
+};
+
+// src/lib/isUrl.ts
+function isUrl(modelOrUrl) {
+  return /^http(s?):/.test(modelOrUrl) || modelOrUrl.startsWith("/");
+}
+
+// src/utils/delay.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
 // src/providers/fal-ai.ts
 var FAL_AI_API_BASE_URL = "https://fal.run";
+var FAL_AI_API_BASE_URL_QUEUE = "https://queue.fal.run";
+var makeBaseUrl4 = (task) => {
+  return task === "text-to-video" ? FAL_AI_API_BASE_URL_QUEUE : FAL_AI_API_BASE_URL;
+};
 var makeBody4 = (params) => {
   return params.args;
 };
@@ -177,17 +212,64 @@ var makeHeaders4 = (params) => {
   };
 };
 var makeUrl4 = (params) => {
-  return `${params.baseUrl}/${params.model}`;
+  const baseUrl = `${params.baseUrl}/${params.model}`;
+  if (params.authMethod !== "provider-key" && params.task === "text-to-video") {
+    return `${baseUrl}?_subdomain=queue`;
+  }
+  return baseUrl;
 };
 var FAL_AI_CONFIG = {
-  baseUrl: FAL_AI_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl4,
   makeBody: makeBody4,
   makeHeaders: makeHeaders4,
   makeUrl: makeUrl4
 };
+async function pollFalResponse(res, url, headers) {
+  const requestId = res.request_id;
+  if (!requestId) {
+    throw new InferenceOutputError("No request ID found in the response");
+  }
+  let status = res.status;
+  const parsedUrl = new URL(url);
+  const baseUrl = `${parsedUrl.protocol}//${parsedUrl.host}${parsedUrl.host === "router.huggingface.co" ? "/fal-ai" : ""}`;
+  const modelId = new URL(res.response_url).pathname;
+  const queryParams = parsedUrl.search;
+  const statusUrl = `${baseUrl}${modelId}/status${queryParams}`;
+  const resultUrl = `${baseUrl}${modelId}${queryParams}`;
+  while (status !== "COMPLETED") {
+    await delay(500);
+    const statusResponse = await fetch(statusUrl, { headers });
+    if (!statusResponse.ok) {
+      throw new InferenceOutputError("Failed to fetch response status from fal-ai API");
+    }
+    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)
+    );
+  }
+}
 
 // src/providers/fireworks-ai.ts
 var FIREWORKS_AI_API_BASE_URL = "https://api.fireworks.ai";
+var makeBaseUrl5 = () => {
+  return FIREWORKS_AI_API_BASE_URL;
+};
 var makeBody5 = (params) => {
   return {
     ...params.args,
@@ -204,13 +286,16 @@ var makeUrl5 = (params) => {
   return `${params.baseUrl}/inference`;
 };
 var FIREWORKS_AI_CONFIG = {
-  baseUrl: FIREWORKS_AI_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl5,
   makeBody: makeBody5,
   makeHeaders: makeHeaders5,
   makeUrl: makeUrl5
 };
 
 // src/providers/hf-inference.ts
+var makeBaseUrl6 = () => {
+  return `${HF_ROUTER_URL}/hf-inference`;
+};
 var makeBody6 = (params) => {
   return {
     ...params.args,
@@ -230,7 +315,7 @@ var makeUrl6 = (params) => {
   return `${params.baseUrl}/models/${params.model}`;
 };
 var HF_INFERENCE_CONFIG = {
-  baseUrl: `${HF_ROUTER_URL}/hf-inference`,
+  makeBaseUrl: makeBaseUrl6,
   makeBody: makeBody6,
   makeHeaders: makeHeaders6,
   makeUrl: makeUrl6
@@ -238,6 +323,9 @@ var HF_INFERENCE_CONFIG = {
 
 // src/providers/hyperbolic.ts
 var HYPERBOLIC_API_BASE_URL = "https://api.hyperbolic.xyz";
+var makeBaseUrl7 = () => {
+  return HYPERBOLIC_API_BASE_URL;
+};
 var makeBody7 = (params) => {
   return {
     ...params.args,
@@ -254,7 +342,7 @@ var makeUrl7 = (params) => {
   return `${params.baseUrl}/v1/chat/completions`;
 };
 var HYPERBOLIC_CONFIG = {
-  baseUrl: HYPERBOLIC_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl7,
   makeBody: makeBody7,
   makeHeaders: makeHeaders7,
   makeUrl: makeUrl7
@@ -262,6 +350,9 @@ var HYPERBOLIC_CONFIG = {
 
 // src/providers/nebius.ts
 var NEBIUS_API_BASE_URL = "https://api.studio.nebius.ai";
+var makeBaseUrl8 = () => {
+  return NEBIUS_API_BASE_URL;
+};
 var makeBody8 = (params) => {
   return {
     ...params.args,
@@ -284,7 +375,7 @@ var makeUrl8 = (params) => {
   return params.baseUrl;
 };
 var NEBIUS_CONFIG = {
-  baseUrl: NEBIUS_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl8,
   makeBody: makeBody8,
   makeHeaders: makeHeaders8,
   makeUrl: makeUrl8
@@ -292,6 +383,9 @@ var NEBIUS_CONFIG = {
 
 // src/providers/novita.ts
 var NOVITA_API_BASE_URL = "https://api.novita.ai";
+var makeBaseUrl9 = () => {
+  return NOVITA_API_BASE_URL;
+};
 var makeBody9 = (params) => {
   return {
     ...params.args,
@@ -312,7 +406,7 @@ var makeUrl9 = (params) => {
   return params.baseUrl;
 };
 var NOVITA_CONFIG = {
-  baseUrl: NOVITA_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl9,
   makeBody: makeBody9,
   makeHeaders: makeHeaders9,
   makeUrl: makeUrl9
@@ -320,6 +414,9 @@ var NOVITA_CONFIG = {
 
 // src/providers/replicate.ts
 var REPLICATE_API_BASE_URL = "https://api.replicate.com";
+var makeBaseUrl10 = () => {
+  return REPLICATE_API_BASE_URL;
+};
 var makeBody10 = (params) => {
   return {
     input: params.args,
@@ -336,7 +433,7 @@ var makeUrl10 = (params) => {
   return `${params.baseUrl}/v1/models/${params.model}/predictions`;
 };
 var REPLICATE_CONFIG = {
-  baseUrl: REPLICATE_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl10,
   makeBody: makeBody10,
   makeHeaders: makeHeaders10,
   makeUrl: makeUrl10
@@ -344,6 +441,9 @@ var REPLICATE_CONFIG = {
 
 // src/providers/sambanova.ts
 var SAMBANOVA_API_BASE_URL = "https://api.sambanova.ai";
+var makeBaseUrl11 = () => {
+  return SAMBANOVA_API_BASE_URL;
+};
 var makeBody11 = (params) => {
   return {
     ...params.args,
@@ -360,7 +460,7 @@ var makeUrl11 = (params) => {
   return params.baseUrl;
 };
 var SAMBANOVA_CONFIG = {
-  baseUrl: SAMBANOVA_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl11,
   makeBody: makeBody11,
   makeHeaders: makeHeaders11,
   makeUrl: makeUrl11
@@ -368,6 +468,9 @@ var SAMBANOVA_CONFIG = {
 
 // src/providers/together.ts
 var TOGETHER_API_BASE_URL = "https://api.together.xyz";
+var makeBaseUrl12 = () => {
+  return TOGETHER_API_BASE_URL;
+};
 var makeBody12 = (params) => {
   return {
     ...params.args,
@@ -390,7 +493,7 @@ var makeUrl12 = (params) => {
   return params.baseUrl;
 };
 var TOGETHER_CONFIG = {
-  baseUrl: TOGETHER_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl12,
   makeBody: makeBody12,
   makeHeaders: makeHeaders12,
   makeUrl: makeUrl12
@@ -398,6 +501,9 @@ var TOGETHER_CONFIG = {
 
 // src/providers/openai.ts
 var OPENAI_API_BASE_URL = "https://api.openai.com";
+var makeBaseUrl13 = () => {
+  return OPENAI_API_BASE_URL;
+};
 var makeBody13 = (params) => {
   if (!params.chatCompletion) {
     throw new Error("OpenAI only supports chat completions.");
@@ -417,21 +523,16 @@ var makeUrl13 = (params) => {
   return `${params.baseUrl}/v1/chat/completions`;
 };
 var OPENAI_CONFIG = {
-  baseUrl: OPENAI_API_BASE_URL,
+  makeBaseUrl: makeBaseUrl13,
   makeBody: makeBody13,
   makeHeaders: makeHeaders13,
   makeUrl: makeUrl13,
   clientSideRoutingOnly: true
 };
 
-// src/lib/isUrl.ts
-function isUrl(modelOrUrl) {
-  return /^http(s?):/.test(modelOrUrl) || modelOrUrl.startsWith("/");
-}
-
 // package.json
 var name = "@huggingface/inference";
-var version = "3.6.1";
+var version = "3.6.2";
 
 // src/providers/consts.ts
 var HARDCODED_MODEL_ID_MAPPING = {
@@ -570,7 +671,8 @@ function makeRequestOptionsFromResolvedModel(resolvedModel, args, options) {
     return "none";
   })();
   const url = endpointUrl ? chatCompletion2 ? endpointUrl + `/v1/chat/completions` : endpointUrl : providerConfig.makeUrl({
-    baseUrl: authMethod !== "provider-key" ? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", provider) : providerConfig.baseUrl,
+    authMethod,
+    baseUrl: authMethod !== "provider-key" ? HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", provider) : providerConfig.makeBaseUrl(task),
     model: resolvedModel,
     chatCompletion: chatCompletion2,
     task
@@ -834,16 +936,6 @@ async function* streamingRequest(args, options) {
   }
 }
 
-// src/lib/InferenceOutputError.ts
-var InferenceOutputError = class extends TypeError {
-  constructor(message) {
-    super(
-      `Invalid inference output: ${message}. Use the 'request' method with the same parameters to do a custom call with no type checking.`
-    );
-    this.name = "InferenceOutputError";
-  }
-};
-
 // src/utils/pick.ts
 function pick(o, props) {
   return Object.assign(
@@ -1058,13 +1150,6 @@ async function objectDetection(args, options) {
   return res;
 }
 
-// src/utils/delay.ts
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(), ms);
-  });
-}
-
 // src/tasks/cv/textToImage.ts
 function getResponseFormatArg(provider) {
   switch (provider) {
@@ -1236,12 +1321,8 @@ async function textToVideo(args, options) {
     task: "text-to-video"
   });
   if (args.provider === "fal-ai") {
-    const isValidOutput = typeof res === "object" && !!res && "video" in res && typeof res.video === "object" && !!res.video && "url" in res.video && typeof res.video.url === "string" && isUrl(res.video.url);
-    if (!isValidOutput) {
-      throw new InferenceOutputError("Expected { video: { url: string } }");
-    }
-    const urlResponse = await fetch(res.video.url);
-    return await urlResponse.blob();
+    const { url, info } = await makeRequestOptions(args, { ...options, task: "text-to-video" });
+    return await pollFalResponse(res, url, info.headers);
   } else if (args.provider === "novita") {
     const isValidOutput = typeof res === "object" && !!res && "video" in res && typeof res.video === "object" && !!res.video && "video_url" in res.video && typeof res.video.video_url === "string" && isUrl(res.video.video_url);
     if (!isValidOutput) {