@huggingface/inference 3.6.1 → 3.7.0

package/dist/index.cjs

@@ -101,9 +101,13 @@ __export(tasks_exports, {
 // src/config.ts
 var HF_HUB_URL = "https://huggingface.co";
 var HF_ROUTER_URL = "https://router.huggingface.co";
+var HF_HEADER_X_BILL_TO = "X-HF-Bill-To";
 
 // src/providers/black-forest-labs.ts
 var BLACK_FOREST_LABS_AI_API_BASE_URL = "https://api.us1.bfl.ai";
+var makeBaseUrl = () => {
+  return BLACK_FOREST_LABS_AI_API_BASE_URL;
+};
 var makeBody = (params) => {
   return params.args;
 };
@@ -118,7 +122,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 +130,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 +146,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 +154,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 +170,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 +213,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 +287,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 +316,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 +324,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 +343,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 +351,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 +376,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 +384,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 +407,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 +415,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 +434,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 +442,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 +461,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 +469,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 +494,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 +502,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 +524,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.7.0";
 
 // src/providers/consts.ts
 var HARDCODED_MODEL_ID_MAPPING = {
@@ -553,7 +655,7 @@ function makeRequestOptionsFromResolvedModel(resolvedModel, args, options) {
   const { accessToken, endpointUrl, provider: maybeProvider, model, ...remainingArgs } = args;
   const provider = maybeProvider ?? "hf-inference";
   const providerConfig = providerConfigs[provider];
-  const { includeCredentials, task, chatCompletion: chatCompletion2, signal } = options ?? {};
+  const { includeCredentials, task, chatCompletion: chatCompletion2, signal, billTo } = options ?? {};
   const authMethod = (() => {
     if (providerConfig.clientSideRoutingOnly) {
       if (accessToken && accessToken.startsWith("hf_")) {
@@ -570,7 +672,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
@@ -580,6 +683,9 @@ function makeRequestOptionsFromResolvedModel(resolvedModel, args, options) {
     accessToken,
     authMethod
   });
+  if (billTo) {
+    headers[HF_HEADER_X_BILL_TO] = billTo;
+  }
   if (!binary) {
     headers["Content-Type"] = "application/json";
   }
@@ -633,37 +739,6 @@ function removeProviderPrefix(model, provider) {
   return model.slice(provider.length + 1);
 }
 
-// src/tasks/custom/request.ts
-async function request(args, options) {
-  const { url, info } = await makeRequestOptions(args, options);
-  const response = await (options?.fetch ?? fetch)(url, info);
-  if (options?.retry_on_error !== false && response.status === 503) {
-    return request(args, options);
-  }
-  if (!response.ok) {
-    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: ${JSON.stringify(output.error)}`
-        );
-      }
-      if (output.error || output.detail) {
-        throw new Error(JSON.stringify(output.error ?? output.detail));
-      } else {
-        throw new Error(output);
-      }
-    }
-    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();
-  }
-  return await response.blob();
-}
-
 // src/vendor/fetch-event-source/parse.ts
 function getLines(onLine) {
   let buffer;
@@ -763,12 +838,44 @@ function newMessage() {
   };
 }
 
-// src/tasks/custom/streamingRequest.ts
-async function* streamingRequest(args, options) {
+// src/utils/request.ts
+async function innerRequest(args, options) {
+  const { url, info } = await makeRequestOptions(args, options);
+  const response = await (options?.fetch ?? fetch)(url, info);
+  const requestContext = { url, info };
+  if (options?.retry_on_error !== false && response.status === 503) {
+    return innerRequest(args, options);
+  }
+  if (!response.ok) {
+    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: ${JSON.stringify(output.error)}`
+        );
+      }
+      if (output.error || output.detail) {
+        throw new Error(JSON.stringify(output.error ?? output.detail));
+      } else {
+        throw new Error(output);
+      }
+    }
+    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")) {
+    const data = await response.json();
+    return { data, requestContext };
+  }
+  const blob = await response.blob();
+  return { data: blob, requestContext };
+}
+async function* innerStreamingRequest(args, options) {
   const { url, info } = await makeRequestOptions({ ...args, stream: true }, options);
   const response = await (options?.fetch ?? fetch)(url, info);
   if (options?.retry_on_error !== false && response.status === 503) {
-    return yield* streamingRequest(args, options);
+    return yield* innerStreamingRequest(args, options);
   }
   if (!response.ok) {
     if (response.headers.get("Content-Type")?.startsWith("application/json")) {
@@ -782,6 +889,9 @@ async function* streamingRequest(args, options) {
       if (output.error && "message" in output.error && typeof output.error.message === "string") {
         throw new Error(output.error.message);
       }
+      if (typeof output.message === "string") {
+        throw new Error(output.message);
+      }
     }
     throw new Error(`Server response contains error: ${response.status}`);
   }
@@ -834,15 +944,22 @@ 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/tasks/custom/request.ts
+async function request(args, options) {
+  console.warn(
+    "The request method is deprecated and will be removed in a future version of huggingface.js. Use specific task functions instead."
+  );
+  const result = await innerRequest(args, options);
+  return result.data;
+}
+
+// src/tasks/custom/streamingRequest.ts
+async function* streamingRequest(args, options) {
+  console.warn(
+    "The streamingRequest method is deprecated and will be removed in a future version of huggingface.js. Use specific task functions instead."
+  );
+  yield* innerStreamingRequest(args, options);
+}
 
 // src/utils/pick.ts
 function pick(o, props) {
@@ -879,7 +996,7 @@ function preparePayload(args) {
 // src/tasks/audio/audioClassification.ts
 async function audioClassification(args, options) {
   const payload = preparePayload(args);
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "audio-classification"
   });
@@ -906,7 +1023,7 @@ function base64FromBytes(arr) {
 // src/tasks/audio/automaticSpeechRecognition.ts
 async function automaticSpeechRecognition(args, options) {
   const payload = await buildPayload(args);
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "automatic-speech-recognition"
   });
@@ -950,7 +1067,7 @@ async function textToSpeech(args, options) {
     ...args.parameters,
     text: args.inputs
   } : args;
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "text-to-speech"
   });
@@ -976,7 +1093,7 @@ async function textToSpeech(args, options) {
 // src/tasks/audio/audioToAudio.ts
 async function audioToAudio(args, options) {
   const payload = preparePayload(args);
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "audio-to-audio"
   });
@@ -1002,7 +1119,7 @@ function preparePayload2(args) {
 // src/tasks/cv/imageClassification.ts
 async function imageClassification(args, options) {
   const payload = preparePayload2(args);
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "image-classification"
   });
@@ -1016,7 +1133,7 @@ async function imageClassification(args, options) {
 // src/tasks/cv/imageSegmentation.ts
 async function imageSegmentation(args, options) {
   const payload = preparePayload2(args);
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "image-segmentation"
   });
@@ -1030,20 +1147,20 @@ async function imageSegmentation(args, options) {
 // src/tasks/cv/imageToText.ts
 async function imageToText(args, options) {
   const payload = preparePayload2(args);
-  const res = (await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "image-to-text"
-  }))?.[0];
-  if (typeof res?.generated_text !== "string") {
+  });
+  if (typeof res?.[0]?.generated_text !== "string") {
     throw new InferenceOutputError("Expected {generated_text: string}");
   }
-  return res;
+  return res?.[0];
 }
 
 // src/tasks/cv/objectDetection.ts
 async function objectDetection(args, options) {
   const payload = preparePayload2(args);
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "object-detection"
   });
@@ -1058,13 +1175,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) {
@@ -1087,7 +1197,7 @@ async function textToImage(args, options) {
     ...getResponseFormatArg(args.provider),
     prompt: args.inputs
   };
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "text-to-image"
   });
@@ -1176,7 +1286,7 @@ async function imageToImage(args, options) {
       )
     };
   }
-  const res = await request(reqArgs, {
+  const { data: res } = await innerRequest(reqArgs, {
     ...options,
     task: "image-to-image"
   });
@@ -1211,7 +1321,7 @@ async function preparePayload3(args) {
 }
 async function zeroShotImageClassification(args, options) {
   const payload = await preparePayload3(args);
-  const res = await request(payload, {
+  const { data: res } = await innerRequest(payload, {
     ...options,
     task: "zero-shot-image-classification"
   });
@@ -1231,37 +1341,36 @@ async function textToVideo(args, options) {
     );
   }
   const payload = args.provider === "fal-ai" || args.provider === "replicate" || args.provider === "novita" ? { ...omit(args, ["inputs", "parameters"]), ...args.parameters, prompt: args.inputs } : args;
-  const res = await request(payload, {
+  const { data, requestContext } = await innerRequest(payload, {
     ...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();
+    return await pollFalResponse(
+      data,
+      requestContext.url,
+      requestContext.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);
+    const isValidOutput = typeof data === "object" && !!data && "video" in data && typeof data.video === "object" && !!data.video && "video_url" in data.video && typeof data.video.video_url === "string" && isUrl(data.video.video_url);
     if (!isValidOutput) {
       throw new InferenceOutputError("Expected { video: { video_url: string } }");
     }
-    const urlResponse = await fetch(res.video.video_url);
+    const urlResponse = await fetch(data.video.video_url);
     return await urlResponse.blob();
   } else {
-    const isValidOutput = typeof res === "object" && !!res && "output" in res && typeof res.output === "string" && isUrl(res.output);
+    const isValidOutput = typeof data === "object" && !!data && "output" in data && typeof data.output === "string" && isUrl(data.output);
     if (!isValidOutput) {
       throw new InferenceOutputError("Expected { output: string }");
     }
-    const urlResponse = await fetch(res.output);
+    const urlResponse = await fetch(data.output);
     return await urlResponse.blob();
   }
 }
 
 // src/tasks/nlp/featureExtraction.ts
 async function featureExtraction(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "feature-extraction"
   });
@@ -1284,7 +1393,7 @@ async function featureExtraction(args, options) {
 
 // src/tasks/nlp/fillMask.ts
 async function fillMask(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "fill-mask"
   });
@@ -1301,7 +1410,7 @@ async function fillMask(args, options) {
 
 // src/tasks/nlp/questionAnswering.ts
 async function questionAnswering(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "question-answering"
   });
@@ -1316,7 +1425,7 @@ async function questionAnswering(args, options) {
 
 // src/tasks/nlp/sentenceSimilarity.ts
 async function sentenceSimilarity(args, options) {
-  const res = await request(prepareInput(args), {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "sentence-similarity"
   });
@@ -1326,17 +1435,10 @@ async function sentenceSimilarity(args, options) {
   }
   return res;
 }
-function prepareInput(args) {
-  return {
-    ...omit(args, ["inputs", "parameters"]),
-    inputs: { ...omit(args.inputs, "sourceSentence") },
-    parameters: { source_sentence: args.inputs.sourceSentence, ...args.parameters }
-  };
-}
 
 // src/tasks/nlp/summarization.ts
 async function summarization(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "summarization"
   });
@@ -1349,7 +1451,7 @@ async function summarization(args, options) {
 
 // src/tasks/nlp/tableQuestionAnswering.ts
 async function tableQuestionAnswering(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "table-question-answering"
   });
@@ -1369,15 +1471,16 @@ function validate(elem) {
 
 // src/tasks/nlp/textClassification.ts
 async function textClassification(args, options) {
-  const res = (await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "text-classification"
-  }))?.[0];
-  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.label === "string" && typeof x.score === "number");
+  });
+  const output = res?.[0];
+  const isValidOutput = Array.isArray(output) && output.every((x) => typeof x?.label === "string" && typeof x.score === "number");
   if (!isValidOutput) {
     throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
   }
-  return res;
+  return output;
 }
 
 // src/utils/toArray.ts
@@ -1392,7 +1495,7 @@ function toArray(obj) {
 async function textGeneration(args, options) {
   if (args.provider === "together") {
     args.prompt = args.inputs;
-    const raw = await request(args, {
+    const { data: raw } = await innerRequest(args, {
       ...options,
       task: "text-generation"
     });
@@ -1413,10 +1516,10 @@ async function textGeneration(args, options) {
       } : void 0,
       ...omit(args, ["inputs", "parameters"])
     };
-    const raw = await request(payload, {
+    const raw = (await innerRequest(payload, {
       ...options,
       task: "text-generation"
-    });
+    })).data;
     const isValidOutput = typeof raw === "object" && "choices" in raw && Array.isArray(raw?.choices) && typeof raw?.model === "string";
     if (!isValidOutput) {
       throw new InferenceOutputError("Expected ChatCompletionOutput");
@@ -1426,23 +1529,22 @@ async function textGeneration(args, options) {
       generated_text: completion.message.content
     };
   } else {
-    const res = toArray(
-      await request(args, {
-        ...options,
-        task: "text-generation"
-      })
-    );
-    const isValidOutput = Array.isArray(res) && res.every((x) => "generated_text" in x && typeof x?.generated_text === "string");
+    const { data: res } = await innerRequest(args, {
+      ...options,
+      task: "text-generation"
+    });
+    const output = toArray(res);
+    const isValidOutput = Array.isArray(output) && output.every((x) => "generated_text" in x && typeof x?.generated_text === "string");
     if (!isValidOutput) {
       throw new InferenceOutputError("Expected Array<{generated_text: string}>");
     }
-    return res?.[0];
+    return output?.[0];
   }
 }
 
 // src/tasks/nlp/textGenerationStream.ts
 async function* textGenerationStream(args, options) {
-  yield* streamingRequest(args, {
+  yield* innerStreamingRequest(args, {
     ...options,
     task: "text-generation"
   });
@@ -1450,13 +1552,12 @@ async function* textGenerationStream(args, options) {
 
 // src/tasks/nlp/tokenClassification.ts
 async function tokenClassification(args, options) {
-  const res = toArray(
-    await request(args, {
-      ...options,
-      task: "token-classification"
-    })
-  );
-  const isValidOutput = Array.isArray(res) && res.every(
+  const { data: res } = await innerRequest(args, {
+    ...options,
+    task: "token-classification"
+  });
+  const output = toArray(res);
+  const isValidOutput = Array.isArray(output) && output.every(
     (x) => typeof x.end === "number" && typeof x.entity_group === "string" && typeof x.score === "number" && typeof x.start === "number" && typeof x.word === "string"
   );
   if (!isValidOutput) {
@@ -1464,12 +1565,12 @@ async function tokenClassification(args, options) {
       "Expected Array<{end: number, entity_group: string, score: number, start: number, word: string}>"
     );
   }
-  return res;
+  return output;
 }
 
 // src/tasks/nlp/translation.ts
 async function translation(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "translation"
   });
@@ -1482,24 +1583,23 @@ async function translation(args, options) {
 
 // src/tasks/nlp/zeroShotClassification.ts
 async function zeroShotClassification(args, options) {
-  const res = toArray(
-    await request(args, {
-      ...options,
-      task: "zero-shot-classification"
-    })
-  );
-  const isValidOutput = Array.isArray(res) && res.every(
+  const { data: res } = await innerRequest(args, {
+    ...options,
+    task: "zero-shot-classification"
+  });
+  const output = toArray(res);
+  const isValidOutput = Array.isArray(output) && output.every(
     (x) => Array.isArray(x.labels) && x.labels.every((_label) => typeof _label === "string") && Array.isArray(x.scores) && x.scores.every((_score) => typeof _score === "number") && typeof x.sequence === "string"
   );
   if (!isValidOutput) {
     throw new InferenceOutputError("Expected Array<{labels: string[], scores: number[], sequence: string}>");
   }
-  return res;
+  return output;
 }
 
 // src/tasks/nlp/chatCompletion.ts
 async function chatCompletion(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "text-generation",
     chatCompletion: true
@@ -1514,7 +1614,7 @@ async function chatCompletion(args, options) {
 
 // src/tasks/nlp/chatCompletionStream.ts
 async function* chatCompletionStream(args, options) {
-  yield* streamingRequest(args, {
+  yield* innerStreamingRequest(args, {
     ...options,
     task: "text-generation",
     chatCompletion: true
@@ -1531,19 +1631,21 @@ async function documentQuestionAnswering(args, options) {
       image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer()))
     }
   };
-  const res = toArray(
-    await request(reqArgs, {
+  const { data: res } = await innerRequest(
+    reqArgs,
+    {
       ...options,
       task: "document-question-answering"
-    })
+    }
   );
-  const isValidOutput = Array.isArray(res) && res.every(
+  const output = toArray(res);
+  const isValidOutput = Array.isArray(output) && output.every(
     (elem) => typeof elem === "object" && !!elem && typeof elem?.answer === "string" && (typeof elem.end === "number" || typeof elem.end === "undefined") && (typeof elem.score === "number" || typeof elem.score === "undefined") && (typeof elem.start === "number" || typeof elem.start === "undefined")
   );
   if (!isValidOutput) {
     throw new InferenceOutputError("Expected Array<{answer: string, end?: number, score?: number, start?: number}>");
   }
-  return res[0];
+  return output[0];
 }
 
 // src/tasks/multimodal/visualQuestionAnswering.ts
@@ -1556,7 +1658,7 @@ async function visualQuestionAnswering(args, options) {
       image: base64FromBytes(new Uint8Array(await args.inputs.image.arrayBuffer()))
     }
   };
-  const res = await request(reqArgs, {
+  const { data: res } = await innerRequest(reqArgs, {
     ...options,
     task: "visual-question-answering"
   });
@@ -1571,7 +1673,7 @@ async function visualQuestionAnswering(args, options) {
 
 // src/tasks/tabular/tabularRegression.ts
 async function tabularRegression(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "tabular-regression"
   });
@@ -1584,7 +1686,7 @@ async function tabularRegression(args, options) {
 
 // src/tasks/tabular/tabularClassification.ts
 async function tabularClassification(args, options) {
-  const res = await request(args, {
+  const { data: res } = await innerRequest(args, {
     ...options,
     task: "tabular-classification"
   });
@@ -1672,7 +1774,7 @@ var templates = {
       "basicAudio": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "audio/flac"\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
       "basicImage": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "image/jpeg"\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.json();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});',
       "textToAudio": '{% if model.library_name == "transformers" %}\nasync function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.blob();\n    return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    // Returns a byte object of the Audio wavform. Use it directly!\n});\n{% else %}\nasync function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n    const result = await response.json();\n    return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    console.log(JSON.stringify(response));\n});\n{% endif %} ',
-      "textToImage": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.blob();\n	return result;\n}\n\nquery({ inputs: {{ providerInputs.asObj.inputs }} }).then((response) => {\n    // Use image\n});',
+      "textToImage": 'async function query(data) {\n	const response = await fetch(\n		"{{ fullUrl }}",\n		{\n			headers: {\n				Authorization: "{{ authorizationHeader }}",\n				"Content-Type": "application/json",\n			},\n			method: "POST",\n			body: JSON.stringify(data),\n		}\n	);\n	const result = await response.blob();\n	return result;\n}\n\n\nquery({ {{ providerInputs.asTsString }} }).then((response) => {\n    // Use image\n});',
       "zeroShotClassification": 'async function query(data) {\n    const response = await fetch(\n		"{{ fullUrl }}",\n        {\n            headers: {\n				Authorization: "{{ authorizationHeader }}",\n                "Content-Type": "application/json",\n            },\n            method: "POST",\n            body: JSON.stringify(data),\n        }\n    );\n    const result = await response.json();\n    return result;\n}\n\nquery({\n    inputs: {{ providerInputs.asObj.inputs }},\n    parameters: { candidate_labels: ["refund", "legal", "faq"] }\n}).then((response) => {\n    console.log(JSON.stringify(response));\n});'
     },
     "huggingface.js": {