@huggingface/inference 1.8.0 → 2.0.0-rc2

package/dist/index.mjs

@@ -1,9 +1,94 @@
-// src/utils/toArray.ts
-function toArray(obj) {
-  if (Array.isArray(obj)) {
-    return obj;
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/tasks/index.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  audioClassification: () => audioClassification,
+  automaticSpeechRecognition: () => automaticSpeechRecognition,
+  conversational: () => conversational,
+  featureExtraction: () => featureExtraction,
+  fillMask: () => fillMask,
+  imageClassification: () => imageClassification,
+  imageSegmentation: () => imageSegmentation,
+  imageToText: () => imageToText,
+  objectDetection: () => objectDetection,
+  questionAnswering: () => questionAnswering,
+  request: () => request,
+  sentenceSimilarity: () => sentenceSimilarity,
+  streamingRequest: () => streamingRequest,
+  summarization: () => summarization,
+  tableQuestionAnswering: () => tableQuestionAnswering,
+  textClassification: () => textClassification,
+  textGeneration: () => textGeneration,
+  textGenerationStream: () => textGenerationStream,
+  textToImage: () => textToImage,
+  tokenClassification: () => tokenClassification,
+  translation: () => translation,
+  zeroShotClassification: () => zeroShotClassification
+});
+
+// src/lib/makeRequestOptions.ts
+var HF_INFERENCE_API_BASE_URL = "https://api-inference.huggingface.co/models/";
+function makeRequestOptions(args, options) {
+  const { model, accessToken, ...otherArgs } = args;
+  const headers = {};
+  if (accessToken) {
+    headers["Authorization"] = `Bearer ${accessToken}`;
   }
-  return [obj];
+  const binary = "data" in args && !!args.data;
+  if (!binary) {
+    headers["Content-Type"] = "application/json";
+  } else {
+    if (options?.wait_for_model) {
+      headers["X-Wait-For-Model"] = "true";
+    }
+    if (options?.use_cache === false) {
+      headers["X-Use-Cache"] = "false";
+    }
+    if (options?.dont_load_model) {
+      headers["X-Load-Model"] = "0";
+    }
+  }
+  const url = /^http(s?):/.test(model) ? model : `${HF_INFERENCE_API_BASE_URL}${model}`;
+  const info = {
+    headers,
+    method: "POST",
+    body: binary ? args.data : JSON.stringify({
+      ...otherArgs,
+      options
+    }),
+    credentials: options?.includeCredentials ? "include" : "same-origin"
+  };
+  return { url, info };
+}
+
+// src/tasks/custom/request.ts
+async function request(args, options) {
+  const { url, info } = makeRequestOptions(args, options);
+  const response = await fetch(url, info);
+  if (options?.retry_on_error !== false && response.status === 503 && !options?.wait_for_model) {
+    return request(args, {
+      ...options,
+      wait_for_model: true
+    });
+  }
+  if (!response.ok) {
+    if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+      const output = await response.json();
+      if (output.error) {
+        throw new Error(output.error);
+      }
+    }
+    throw new Error("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
@@ -105,389 +190,374 @@ function newMessage() {
   };
 }
 
-// src/HfInference.ts
-var HF_INFERENCE_API_BASE_URL = "https://api-inference.huggingface.co/models/";
-var TextGenerationStreamFinishReason = /* @__PURE__ */ ((TextGenerationStreamFinishReason2) => {
-  TextGenerationStreamFinishReason2["Length"] = "length";
-  TextGenerationStreamFinishReason2["EndOfSequenceToken"] = "eos_token";
-  TextGenerationStreamFinishReason2["StopSequence"] = "stop_sequence";
-  return TextGenerationStreamFinishReason2;
-})(TextGenerationStreamFinishReason || {});
-var HfInference = class {
-  apiKey;
-  defaultOptions;
-  constructor(apiKey = "", defaultOptions = {}) {
-    this.apiKey = apiKey;
-    this.defaultOptions = defaultOptions;
+// src/tasks/custom/streamingRequest.ts
+async function* streamingRequest(args, options) {
+  const { url, info } = makeRequestOptions({ ...args, stream: true }, options);
+  const response = await fetch(url, info);
+  if (options?.retry_on_error !== false && response.status === 503 && !options?.wait_for_model) {
+    return streamingRequest(args, {
+      ...options,
+      wait_for_model: true
+    });
   }
-  /**
-   * Tries to fill in a hole with a missing word (token to be precise). That’s the base task for BERT models.
-   */
-  async fillMask(args, options) {
-    const res = await this.request(args, options);
-    const isValidOutput = Array.isArray(res) && res.every(
-      (x) => typeof x.score === "number" && typeof x.sequence === "string" && typeof x.token === "number" && typeof x.token_str === "string"
-    );
-    if (!isValidOutput) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type Array<score: number, sequence:string, token:number, token_str:string>"
-      );
+  if (!response.ok) {
+    if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+      const output = await response.json();
+      if (output.error) {
+        throw new Error(output.error);
+      }
     }
-    return res;
+    throw new Error(`Server response contains error: ${response.status}`);
   }
-  /**
-   * This task is well known to summarize longer text into shorter text. Be careful, some models have a maximum length of input. That means that the summary cannot handle full books for instance. Be careful when choosing your model.
-   */
-  async summarization(args, options) {
-    const res = await this.request(args, options);
-    const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.summary_text === "string");
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type Array<summary_text: string>");
-    }
-    return res?.[0];
+  if (response.headers.get("content-type") !== "text/event-stream") {
+    throw new Error(
+      `Server does not support event stream content type, it returned ` + response.headers.get("content-type")
+    );
   }
-  /**
-   * Want to have a nice know-it-all bot that can answer any question?. Recommended model: deepset/roberta-base-squad2
-   */
-  async questionAnswer(args, options) {
-    const res = await this.request(args, options);
-    const isValidOutput = typeof res.answer === "string" && typeof res.end === "number" && typeof res.score === "number" && typeof res.start === "number";
-    if (!isValidOutput) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type <answer: string, end: number, score: number, start: number>"
-      );
-    }
-    return res;
+  if (!response.body) {
+    return;
   }
-  /**
-   * Don’t know SQL? Don’t want to dive into a large spreadsheet? Ask questions in plain english! Recommended model: google/tapas-base-finetuned-wtq.
-   */
-  async tableQuestionAnswer(args, options) {
-    const res = await this.request(args, options);
-    const isValidOutput = typeof res.aggregator === "string" && typeof res.answer === "string" && Array.isArray(res.cells) && res.cells.every((x) => typeof x === "string") && Array.isArray(res.coordinates) && res.coordinates.every((coord) => Array.isArray(coord) && coord.every((x) => typeof x === "number"));
-    if (!isValidOutput) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type <aggregator: string, answer: string, cells: string[], coordinates: number[][]>"
-      );
+  const reader = response.body.getReader();
+  let events = [];
+  const onEvent = (event) => {
+    events.push(event);
+  };
+  const onChunk = getLines(
+    getMessages(
+      () => {
+      },
+      () => {
+      },
+      onEvent
+    )
+  );
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        return;
+      onChunk(value);
+      for (const event of events) {
+        if (event.data.length > 0) {
+          yield JSON.parse(event.data);
+        }
+      }
+      events = [];
     }
-    return res;
+  } finally {
+    reader.releaseLock();
   }
-  /**
-   * Usually used for sentiment-analysis this will output the likelihood of classes of an input. Recommended model: distilbert-base-uncased-finetuned-sst-2-english
-   */
-  async textClassification(args, options) {
-    const res = (await this.request(args, options))?.[0];
-    const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type Array<label: string, score: number>");
-    }
-    return res;
+}
+
+// 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";
   }
-  /**
-   * Use to continue text from a prompt. This is a very generic task. Recommended model: gpt2 (it’s a simple model, but fun to play with).
-   */
-  async textGeneration(args, options) {
-    const res = await this.request(args, options);
-    const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.generated_text === "string");
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type Array<generated_text: string>");
-    }
-    return res?.[0];
+};
+
+// src/tasks/audio/audioClassification.ts
+async function audioClassification(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
   }
-  /**
-   * Use to continue text from a prompt. Same as `textGeneration` but returns generator that can be read one token at a time
-   */
-  async *textGenerationStream(args, options) {
-    yield* this.streamingRequest(args, options);
+  return res;
+}
+
+// src/tasks/audio/automaticSpeechRecognition.ts
+async function automaticSpeechRecognition(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = typeof res?.text === "string";
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected {text: string}");
   }
-  /**
-   * Usually used for sentence parsing, either grammatical, or Named Entity Recognition (NER) to understand keywords contained within text. Recommended model: dbmdz/bert-large-cased-finetuned-conll03-english
-   */
-  async tokenClassification(args, options) {
-    const res = toArray(await this.request(args, options));
-    const isValidOutput = Array.isArray(res) && res.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) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type Array<end: number, entity_group: string, score: number, start: number, word: string>"
-      );
-    }
-    return res;
+  return res;
+}
+
+// src/tasks/cv/imageClassification.ts
+async function imageClassification(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
   }
-  /**
-   * This task is well known to translate text from one language to another. Recommended model: Helsinki-NLP/opus-mt-ru-en.
-   */
-  async translation(args, options) {
-    const res = await this.request(args, options);
-    const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.translation_text === "string");
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type Array<translation_text: string>");
-    }
-    return res?.[0];
+  return res;
+}
+
+// src/tasks/cv/imageSegmentation.ts
+async function imageSegmentation(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.mask === "string" && typeof x.score === "number");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Array<{label: string, mask: string, score: number}>");
   }
-  /**
-   * This task is super useful to try out classification with zero code, you simply pass a sentence/paragraph and the possible labels for that sentence, and you get a result. Recommended model: facebook/bart-large-mnli.
-   */
-  async zeroShotClassification(args, options) {
-    const res = toArray(
-      await this.request(args, options)
+  return res;
+}
+
+// src/tasks/cv/imageToText.ts
+async function imageToText(args, options) {
+  const res = (await request(args, options))?.[0];
+  if (typeof res?.generated_text !== "string") {
+    throw new InferenceOutputError("Expected {generated_text: string}");
+  }
+  return res;
+}
+
+// src/tasks/cv/objectDetection.ts
+async function objectDetection(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every(
+    (x) => typeof x.label === "string" && typeof x.score === "number" && typeof x.box.xmin === "number" && typeof x.box.ymin === "number" && typeof x.box.xmax === "number" && typeof x.box.ymax === "number"
+  );
+  if (!isValidOutput) {
+    throw new InferenceOutputError(
+      "Expected Array<{label:string; score:number; box:{xmin:number; ymin:number; xmax:number; ymax:number}}>"
     );
-    const isValidOutput = Array.isArray(res) && res.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 res;
+}
+
+// src/tasks/cv/textToImage.ts
+async function textToImage(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = res && res instanceof Blob;
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Blob");
+  }
+  return res;
+}
+
+// src/tasks/nlp/conversational.ts
+async function conversational(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res.conversation.generated_responses) && res.conversation.generated_responses.every((x) => typeof x === "string") && Array.isArray(res.conversation.past_user_inputs) && res.conversation.past_user_inputs.every((x) => typeof x === "string") && typeof res.generated_text === "string" && Array.isArray(res.warnings) && res.warnings.every((x) => typeof x === "string");
+  if (!isValidOutput) {
+    throw new InferenceOutputError(
+      "Expected {conversation: {generated_responses: string[], past_user_inputs: string[]}, generated_text: string, warnings: string[]}"
     );
-    if (!isValidOutput) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type Array<labels: string[], scores: number[], sequence: string>"
-      );
-    }
-    return res;
   }
-  /**
-   * This task corresponds to any chatbot like structure. Models tend to have shorter max_length, so please check with caution when using a given model if you need long range dependency or not. Recommended model: microsoft/DialoGPT-large.
-   *
-   */
-  async conversational(args, options) {
-    const res = await this.request(args, options);
-    const isValidOutput = Array.isArray(res.conversation.generated_responses) && res.conversation.generated_responses.every((x) => typeof x === "string") && Array.isArray(res.conversation.past_user_inputs) && res.conversation.past_user_inputs.every((x) => typeof x === "string") && typeof res.generated_text === "string" && Array.isArray(res.warnings) && res.warnings.every((x) => typeof x === "string");
-    if (!isValidOutput) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type <conversation: {generated_responses: string[], past_user_inputs: string[]}, generated_text: string, warnings: string[]>"
-      );
+  return res;
+}
+
+// src/tasks/nlp/featureExtraction.ts
+async function featureExtraction(args, options) {
+  const res = await request(args, options);
+  let isValidOutput = true;
+  if (Array.isArray(res)) {
+    for (const e of res) {
+      if (Array.isArray(e)) {
+        isValidOutput = e.every((x) => typeof x === "number");
+        if (!isValidOutput) {
+          break;
+        }
+      } else if (typeof e !== "number") {
+        isValidOutput = false;
+        break;
+      }
     }
-    return res;
+  } else {
+    isValidOutput = false;
   }
-  /**
-   * This task reads some text and outputs raw float values, that are usually consumed as part of a semantic database/semantic search.
-   */
-  async featureExtraction(args, options) {
-    const res = await this.request(args, options);
-    return res;
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Array<number[] | number>");
   }
-  /**
-   * This task reads some audio input and outputs the said words within the audio files.
-   * Recommended model (english language): facebook/wav2vec2-large-960h-lv60-self
-   */
-  async automaticSpeechRecognition(args, options) {
-    const res = await this.request(args, {
-      ...options,
-      binary: true
-    });
-    const isValidOutput = typeof res.text === "string";
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type <text: string>");
-    }
-    return res;
+  return res;
+}
+
+// src/tasks/nlp/fillMask.ts
+async function fillMask(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every(
+    (x) => typeof x.score === "number" && typeof x.sequence === "string" && typeof x.token === "number" && typeof x.token_str === "string"
+  );
+  if (!isValidOutput) {
+    throw new InferenceOutputError(
+      "Expected Array<{score: number, sequence: string, token: number, token_str: string}>"
+    );
   }
-  /**
-   * This task reads some audio input and outputs the likelihood of classes.
-   * Recommended model:  superb/hubert-large-superb-er
-   */
-  async audioClassification(args, options) {
-    const res = await this.request(args, {
-      ...options,
-      binary: true
-    });
-    const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type Array<label: string, score: number>");
-    }
-    return res;
+  return res;
+}
+
+// src/tasks/nlp/questionAnswering.ts
+async function questionAnswering(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = typeof res?.answer === "string" && typeof res.end === "number" && typeof res.score === "number" && typeof res.start === "number";
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected {answer: string, end: number, score: number, start: number}");
   }
-  /**
-   * This task reads some image input and outputs the likelihood of classes.
-   * Recommended model: google/vit-base-patch16-224
-   */
-  async imageClassification(args, options) {
-    const res = await this.request(args, {
-      ...options,
-      binary: true
-    });
-    const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.score === "number");
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type Array<label: string, score: number>");
-    }
-    return res;
+  return res;
+}
+
+// src/tasks/nlp/sentenceSimilarity.ts
+async function sentenceSimilarity(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x === "number");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected number[]");
   }
-  /**
-   * This task reads some image input and outputs the likelihood of classes & bounding boxes of detected objects.
-   * Recommended model: facebook/detr-resnet-50
-   */
-  async objectDetection(args, options) {
-    const res = await this.request(args, {
-      ...options,
-      binary: true
-    });
-    const isValidOutput = Array.isArray(res) && res.every(
-      (x) => typeof x.label === "string" && typeof x.score === "number" && typeof x.box.xmin === "number" && typeof x.box.ymin === "number" && typeof x.box.xmax === "number" && typeof x.box.ymax === "number"
+  return res;
+}
+
+// src/tasks/nlp/summarization.ts
+async function summarization(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.summary_text === "string");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Array<{summary_text: string}>");
+  }
+  return res?.[0];
+}
+
+// src/tasks/nlp/tableQuestionAnswering.ts
+async function tableQuestionAnswering(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = typeof res?.aggregator === "string" && typeof res.answer === "string" && Array.isArray(res.cells) && res.cells.every((x) => typeof x === "string") && Array.isArray(res.coordinates) && res.coordinates.every((coord) => Array.isArray(coord) && coord.every((x) => typeof x === "number"));
+  if (!isValidOutput) {
+    throw new InferenceOutputError(
+      "Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}"
     );
-    if (!isValidOutput) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type Array<{label:string; score:number; box:{xmin:number; ymin:number; xmax:number; ymax:number}}>"
-      );
-    }
-    return res;
   }
-  /**
-   * This task reads some image input and outputs the likelihood of classes & bounding boxes of detected objects.
-   * Recommended model: facebook/detr-resnet-50-panoptic
-   */
-  async imageSegmentation(args, options) {
-    const res = await this.request(args, {
-      ...options,
-      binary: true
-    });
-    const isValidOutput = Array.isArray(res) && res.every((x) => typeof x.label === "string" && typeof x.mask === "string" && typeof x.score === "number");
-    if (!isValidOutput) {
-      throw new TypeError(
-        "Invalid inference output: output must be of type Array<label: string, mask: string, score: number>"
-      );
-    }
-    return res;
+  return res;
+}
+
+// src/tasks/nlp/textClassification.ts
+async function textClassification(args, options) {
+  const res = (await request(args, options))?.[0];
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.label === "string" && typeof x.score === "number");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Array<{label: string, score: number}>");
   }
-  /**
-   * This task reads some text input and outputs an image.
-   * Recommended model: stabilityai/stable-diffusion-2
-   */
-  async textToImage(args, options) {
-    const res = await this.request(args, {
-      ...options,
-      blob: true
-    });
-    const isValidOutput = res && res instanceof Blob;
-    if (!isValidOutput) {
-      throw new TypeError("Invalid inference output: output must be of type object & of instance Blob");
-    }
-    return res;
+  return res;
+}
+
+// src/tasks/nlp/textGeneration.ts
+async function textGeneration(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.generated_text === "string");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected Array<{generated_text: string}>");
   }
-  /**
-   * This task reads some image input and outputs the text caption.
-   */
-  async imageToText(args, options) {
-    return (await this.request(args, {
-      ...options,
-      binary: true
-    }))?.[0];
+  return res?.[0];
+}
+
+// src/tasks/nlp/textGenerationStream.ts
+async function* textGenerationStream(args, options) {
+  yield* streamingRequest(args, options);
+}
+
+// src/utils/toArray.ts
+function toArray(obj) {
+  if (Array.isArray(obj)) {
+    return obj;
   }
-  /**
-   * Helper that prepares request arguments
-   */
-  makeRequestOptions(args, options) {
-    const mergedOptions = { ...this.defaultOptions, ...options };
-    const { model, ...otherArgs } = args;
-    const headers = {};
-    if (this.apiKey) {
-      headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (!options?.binary) {
-      headers["Content-Type"] = "application/json";
-    }
-    if (options?.binary) {
-      if (mergedOptions.wait_for_model) {
-        headers["X-Wait-For-Model"] = "true";
-      }
-      if (mergedOptions.use_cache === false) {
-        headers["X-Use-Cache"] = "false";
-      }
-      if (mergedOptions.dont_load_model) {
-        headers["X-Load-Model"] = "0";
-      }
-    }
-    const url = `${HF_INFERENCE_API_BASE_URL}${model}`;
-    const info = {
-      headers,
-      method: "POST",
-      body: options?.binary ? args.data : JSON.stringify({
-        ...otherArgs,
-        options: mergedOptions
-      }),
-      credentials: options?.includeCredentials ? "include" : "same-origin"
-    };
-    return { url, info, mergedOptions };
-  }
-  async request(args, options) {
-    const { url, info, mergedOptions } = this.makeRequestOptions(args, options);
-    const response = await fetch(url, info);
-    if (mergedOptions.retry_on_error !== false && response.status === 503 && !mergedOptions.wait_for_model) {
-      return this.request(args, {
-        ...mergedOptions,
-        wait_for_model: true
+  return [obj];
+}
+
+// src/tasks/nlp/tokenClassification.ts
+async function tokenClassification(args, options) {
+  const res = toArray(await request(args, options));
+  const isValidOutput = Array.isArray(res) && res.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) {
+    throw new InferenceOutputError(
+      "Expected Array<{end: number, entity_group: string, score: number, start: number, word: string}>"
+    );
+  }
+  return res;
+}
+
+// src/tasks/nlp/translation.ts
+async function translation(args, options) {
+  const res = await request(args, options);
+  const isValidOutput = Array.isArray(res) && res.every((x) => typeof x?.translation_text === "string");
+  if (!isValidOutput) {
+    throw new InferenceOutputError("Expected type Array<{translation_text: string}>");
+  }
+  return res?.[0];
+}
+
+// src/tasks/nlp/zeroShotClassification.ts
+async function zeroShotClassification(args, options) {
+  const res = toArray(
+    await request(args, options)
+  );
+  const isValidOutput = Array.isArray(res) && res.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;
+}
+
+// src/HfInference.ts
+var HfInference = class {
+  accessToken;
+  defaultOptions;
+  constructor(accessToken = "", defaultOptions = {}) {
+    this.accessToken = accessToken;
+    this.defaultOptions = defaultOptions;
+    for (const [name, fn] of Object.entries(tasks_exports)) {
+      Object.defineProperty(this, name, {
+        enumerable: false,
+        value: (params, options) => (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          fn({ ...params, accessToken }, { ...defaultOptions, ...options })
+        )
       });
     }
-    if (options?.blob) {
-      if (!response.ok) {
-        throw new Error("An error occurred while fetching the blob");
-      }
-      return await response.blob();
-    }
-    const output = await response.json();
-    if (output.error) {
-      throw new Error(output.error);
-    }
-    return output;
   }
   /**
-   * Make request that uses server-sent events and returns response as a generator
+   * Returns copy of HfInference tied to a specified endpoint.
    */
-  async *streamingRequest(args, options) {
-    const { url, info, mergedOptions } = this.makeRequestOptions({ ...args, stream: true }, options);
-    const response = await fetch(url, info);
-    if (mergedOptions.retry_on_error !== false && response.status === 503 && !mergedOptions.wait_for_model) {
-      return this.streamingRequest(args, {
-        ...mergedOptions,
-        wait_for_model: true
+  endpoint(endpointUrl) {
+    return new HfInferenceEndpoint(endpointUrl, this.accessToken, this.defaultOptions);
+  }
+};
+var HfInferenceEndpoint = class {
+  constructor(endpointUrl, accessToken = "", defaultOptions = {}) {
+    accessToken;
+    defaultOptions;
+    for (const [name, fn] of Object.entries(tasks_exports)) {
+      Object.defineProperty(this, name, {
+        enumerable: false,
+        value: (params, options) => (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          fn({ ...params, accessToken, model: endpointUrl }, { ...defaultOptions, ...options })
+        )
       });
     }
-    if (!response.ok) {
-      if (response.headers.get("Content-Type")?.startsWith("application/json")) {
-        const output = await response.json();
-        if (output.error) {
-          throw new Error(output.error);
-        }
-      }
-      throw new Error(`Server response contains error: ${response.status}`);
-    }
-    if (response.headers.get("content-type") !== "text/event-stream") {
-      throw new Error(
-        `Server does not support event stream content type, it returned ` + response.headers.get("content-type")
-      );
-    }
-    if (!response.body) {
-      return;
-    }
-    const reader = response.body.getReader();
-    let events = [];
-    const onEvent = (event) => {
-      events.push(event);
-    };
-    const onChunk = getLines(
-      getMessages(
-        () => {
-        },
-        () => {
-        },
-        onEvent
-      )
-    );
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          return;
-        onChunk(value);
-        for (const event of events) {
-          if (event.data.length > 0) {
-            yield JSON.parse(event.data);
-          }
-        }
-        events = [];
-      }
-    } finally {
-      reader.releaseLock();
-    }
   }
 };
 export {
   HfInference,
-  TextGenerationStreamFinishReason
+  HfInferenceEndpoint,
+  audioClassification,
+  automaticSpeechRecognition,
+  conversational,
+  featureExtraction,
+  fillMask,
+  imageClassification,
+  imageSegmentation,
+  imageToText,
+  objectDetection,
+  questionAnswering,
+  request,
+  sentenceSimilarity,
+  streamingRequest,
+  summarization,
+  tableQuestionAnswering,
+  textClassification,
+  textGeneration,
+  textGenerationStream,
+  textToImage,
+  tokenClassification,
+  translation,
+  zeroShotClassification
 };