@huggingface/inference 3.4.0 → 3.5.0

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(src_exports, {
   questionAnswering: () => questionAnswering,
   request: () => request,
   sentenceSimilarity: () => sentenceSimilarity,
+  snippets: () => snippets_exports,
   streamingRequest: () => streamingRequest,
   summarization: () => summarization,
   tableQuestionAnswering: () => tableQuestionAnswering,
@@ -122,8 +123,8 @@ var BLACK_FOREST_LABS_CONFIG = {
   makeUrl
 };
 
-// src/providers/cohere.ts
-var COHERE_API_BASE_URL = "https://api.cohere.com";
+// src/providers/cerebras.ts
+var CEREBRAS_API_BASE_URL = "https://api.cerebras.ai";
 var makeBody2 = (params) => {
   return {
     ...params.args,
@@ -134,47 +135,68 @@ var makeHeaders2 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
 var makeUrl2 = (params) => {
-  return `${params.baseUrl}/compatibility/v1/chat/completions`;
+  return `${params.baseUrl}/v1/chat/completions`;
 };
-var COHERE_CONFIG = {
-  baseUrl: COHERE_API_BASE_URL,
+var CEREBRAS_CONFIG = {
+  baseUrl: CEREBRAS_API_BASE_URL,
   makeBody: makeBody2,
   makeHeaders: makeHeaders2,
   makeUrl: makeUrl2
 };
 
+// src/providers/cohere.ts
+var COHERE_API_BASE_URL = "https://api.cohere.com";
+var makeBody3 = (params) => {
+  return {
+    ...params.args,
+    model: params.model
+  };
+};
+var makeHeaders3 = (params) => {
+  return { Authorization: `Bearer ${params.accessToken}` };
+};
+var makeUrl3 = (params) => {
+  return `${params.baseUrl}/compatibility/v1/chat/completions`;
+};
+var COHERE_CONFIG = {
+  baseUrl: COHERE_API_BASE_URL,
+  makeBody: makeBody3,
+  makeHeaders: makeHeaders3,
+  makeUrl: makeUrl3
+};
+
 // src/providers/fal-ai.ts
 var FAL_AI_API_BASE_URL = "https://fal.run";
-var makeBody3 = (params) => {
+var makeBody4 = (params) => {
   return params.args;
 };
-var makeHeaders3 = (params) => {
+var makeHeaders4 = (params) => {
   return {
     Authorization: params.authMethod === "provider-key" ? `Key ${params.accessToken}` : `Bearer ${params.accessToken}`
   };
 };
-var makeUrl3 = (params) => {
+var makeUrl4 = (params) => {
   return `${params.baseUrl}/${params.model}`;
 };
 var FAL_AI_CONFIG = {
   baseUrl: FAL_AI_API_BASE_URL,
-  makeBody: makeBody3,
-  makeHeaders: makeHeaders3,
-  makeUrl: makeUrl3
+  makeBody: makeBody4,
+  makeHeaders: makeHeaders4,
+  makeUrl: makeUrl4
 };
 
 // src/providers/fireworks-ai.ts
 var FIREWORKS_AI_API_BASE_URL = "https://api.fireworks.ai/inference";
-var makeBody4 = (params) => {
+var makeBody5 = (params) => {
   return {
     ...params.args,
     ...params.chatCompletion ? { model: params.model } : void 0
   };
 };
-var makeHeaders4 = (params) => {
+var makeHeaders5 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl4 = (params) => {
+var makeUrl5 = (params) => {
   if (params.task === "text-generation" && params.chatCompletion) {
     return `${params.baseUrl}/v1/chat/completions`;
   }
@@ -182,22 +204,22 @@ var makeUrl4 = (params) => {
 };
 var FIREWORKS_AI_CONFIG = {
   baseUrl: FIREWORKS_AI_API_BASE_URL,
-  makeBody: makeBody4,
-  makeHeaders: makeHeaders4,
-  makeUrl: makeUrl4
+  makeBody: makeBody5,
+  makeHeaders: makeHeaders5,
+  makeUrl: makeUrl5
 };
 
 // src/providers/hf-inference.ts
-var makeBody5 = (params) => {
+var makeBody6 = (params) => {
   return {
     ...params.args,
     ...params.chatCompletion ? { model: params.model } : void 0
   };
 };
-var makeHeaders5 = (params) => {
+var makeHeaders6 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl5 = (params) => {
+var makeUrl6 = (params) => {
   if (params.task && ["feature-extraction", "sentence-similarity"].includes(params.task)) {
     return `${params.baseUrl}/pipeline/${params.task}/${params.model}`;
   }
@@ -208,23 +230,23 @@ var makeUrl5 = (params) => {
 };
 var HF_INFERENCE_CONFIG = {
   baseUrl: `${HF_ROUTER_URL}/hf-inference`,
-  makeBody: makeBody5,
-  makeHeaders: makeHeaders5,
-  makeUrl: makeUrl5
+  makeBody: makeBody6,
+  makeHeaders: makeHeaders6,
+  makeUrl: makeUrl6
 };
 
 // src/providers/hyperbolic.ts
 var HYPERBOLIC_API_BASE_URL = "https://api.hyperbolic.xyz";
-var makeBody6 = (params) => {
+var makeBody7 = (params) => {
   return {
     ...params.args,
     ...params.task === "text-to-image" ? { model_name: params.model } : { model: params.model }
   };
 };
-var makeHeaders6 = (params) => {
+var makeHeaders7 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl6 = (params) => {
+var makeUrl7 = (params) => {
   if (params.task === "text-to-image") {
     return `${params.baseUrl}/v1/images/generations`;
   }
@@ -232,23 +254,23 @@ var makeUrl6 = (params) => {
 };
 var HYPERBOLIC_CONFIG = {
   baseUrl: HYPERBOLIC_API_BASE_URL,
-  makeBody: makeBody6,
-  makeHeaders: makeHeaders6,
-  makeUrl: makeUrl6
+  makeBody: makeBody7,
+  makeHeaders: makeHeaders7,
+  makeUrl: makeUrl7
 };
 
 // src/providers/nebius.ts
 var NEBIUS_API_BASE_URL = "https://api.studio.nebius.ai";
-var makeBody7 = (params) => {
+var makeBody8 = (params) => {
   return {
     ...params.args,
     model: params.model
   };
 };
-var makeHeaders7 = (params) => {
+var makeHeaders8 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl7 = (params) => {
+var makeUrl8 = (params) => {
   if (params.task === "text-to-image") {
     return `${params.baseUrl}/v1/images/generations`;
   }
@@ -262,23 +284,23 @@ var makeUrl7 = (params) => {
 };
 var NEBIUS_CONFIG = {
   baseUrl: NEBIUS_API_BASE_URL,
-  makeBody: makeBody7,
-  makeHeaders: makeHeaders7,
-  makeUrl: makeUrl7
+  makeBody: makeBody8,
+  makeHeaders: makeHeaders8,
+  makeUrl: makeUrl8
 };
 
 // src/providers/novita.ts
 var NOVITA_API_BASE_URL = "https://api.novita.ai/v3/openai";
-var makeBody8 = (params) => {
+var makeBody9 = (params) => {
   return {
     ...params.args,
     ...params.chatCompletion ? { model: params.model } : void 0
   };
 };
-var makeHeaders8 = (params) => {
+var makeHeaders9 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl8 = (params) => {
+var makeUrl9 = (params) => {
   if (params.task === "text-generation") {
     if (params.chatCompletion) {
       return `${params.baseUrl}/chat/completions`;
@@ -289,23 +311,23 @@ var makeUrl8 = (params) => {
 };
 var NOVITA_CONFIG = {
   baseUrl: NOVITA_API_BASE_URL,
-  makeBody: makeBody8,
-  makeHeaders: makeHeaders8,
-  makeUrl: makeUrl8
+  makeBody: makeBody9,
+  makeHeaders: makeHeaders9,
+  makeUrl: makeUrl9
 };
 
 // src/providers/replicate.ts
 var REPLICATE_API_BASE_URL = "https://api.replicate.com";
-var makeBody9 = (params) => {
+var makeBody10 = (params) => {
   return {
     input: params.args,
     version: params.model.includes(":") ? params.model.split(":")[1] : void 0
   };
 };
-var makeHeaders9 = (params) => {
+var makeHeaders10 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl9 = (params) => {
+var makeUrl10 = (params) => {
   if (params.model.includes(":")) {
     return `${params.baseUrl}/v1/predictions`;
   }
@@ -313,23 +335,23 @@ var makeUrl9 = (params) => {
 };
 var REPLICATE_CONFIG = {
   baseUrl: REPLICATE_API_BASE_URL,
-  makeBody: makeBody9,
-  makeHeaders: makeHeaders9,
-  makeUrl: makeUrl9
+  makeBody: makeBody10,
+  makeHeaders: makeHeaders10,
+  makeUrl: makeUrl10
 };
 
 // src/providers/sambanova.ts
 var SAMBANOVA_API_BASE_URL = "https://api.sambanova.ai";
-var makeBody10 = (params) => {
+var makeBody11 = (params) => {
   return {
     ...params.args,
     ...params.chatCompletion ? { model: params.model } : void 0
   };
 };
-var makeHeaders10 = (params) => {
+var makeHeaders11 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl10 = (params) => {
+var makeUrl11 = (params) => {
   if (params.task === "text-generation" && params.chatCompletion) {
     return `${params.baseUrl}/v1/chat/completions`;
   }
@@ -337,23 +359,23 @@ var makeUrl10 = (params) => {
 };
 var SAMBANOVA_CONFIG = {
   baseUrl: SAMBANOVA_API_BASE_URL,
-  makeBody: makeBody10,
-  makeHeaders: makeHeaders10,
-  makeUrl: makeUrl10
+  makeBody: makeBody11,
+  makeHeaders: makeHeaders11,
+  makeUrl: makeUrl11
 };
 
 // src/providers/together.ts
 var TOGETHER_API_BASE_URL = "https://api.together.xyz";
-var makeBody11 = (params) => {
+var makeBody12 = (params) => {
   return {
     ...params.args,
     model: params.model
   };
 };
-var makeHeaders11 = (params) => {
+var makeHeaders12 = (params) => {
   return { Authorization: `Bearer ${params.accessToken}` };
 };
-var makeUrl11 = (params) => {
+var makeUrl12 = (params) => {
   if (params.task === "text-to-image") {
     return `${params.baseUrl}/v1/images/generations`;
   }
@@ -367,9 +389,37 @@ var makeUrl11 = (params) => {
 };
 var TOGETHER_CONFIG = {
   baseUrl: TOGETHER_API_BASE_URL,
-  makeBody: makeBody11,
-  makeHeaders: makeHeaders11,
-  makeUrl: makeUrl11
+  makeBody: makeBody12,
+  makeHeaders: makeHeaders12,
+  makeUrl: makeUrl12
+};
+
+// src/providers/openai.ts
+var OPENAI_API_BASE_URL = "https://api.openai.com";
+var makeBody13 = (params) => {
+  if (!params.chatCompletion) {
+    throw new Error("OpenAI only supports chat completions.");
+  }
+  return {
+    ...params.args,
+    model: params.model
+  };
+};
+var makeHeaders13 = (params) => {
+  return { Authorization: `Bearer ${params.accessToken}` };
+};
+var makeUrl13 = (params) => {
+  if (!params.chatCompletion) {
+    throw new Error("OpenAI only supports chat completions.");
+  }
+  return `${params.baseUrl}/v1/chat/completions`;
+};
+var OPENAI_CONFIG = {
+  baseUrl: OPENAI_API_BASE_URL,
+  makeBody: makeBody13,
+  makeHeaders: makeHeaders13,
+  makeUrl: makeUrl13,
+  clientSideRoutingOnly: true
 };
 
 // src/lib/isUrl.ts
@@ -379,7 +429,7 @@ function isUrl(modelOrUrl) {
 
 // package.json
 var name = "@huggingface/inference";
-var version = "3.4.0";
+var version = "3.5.0";
 
 // src/providers/consts.ts
 var HARDCODED_MODEL_ID_MAPPING = {
@@ -390,6 +440,7 @@ var HARDCODED_MODEL_ID_MAPPING = {
    * "Qwen/Qwen2.5-Coder-32B-Instruct": "Qwen2.5-Coder-32B-Instruct",
    */
   "black-forest-labs": {},
+  cerebras: {},
   cohere: {},
   "fal-ai": {},
   "fireworks-ai": {},
@@ -397,6 +448,7 @@ var HARDCODED_MODEL_ID_MAPPING = {
   hyperbolic: {},
   nebius: {},
   novita: {},
+  openai: {},
   replicate: {},
   sambanova: {},
   together: {}
@@ -451,11 +503,13 @@ var HF_HUB_INFERENCE_PROXY_TEMPLATE = `${HF_ROUTER_URL}/{{PROVIDER}}`;
 var tasks = null;
 var providerConfigs = {
   "black-forest-labs": BLACK_FOREST_LABS_CONFIG,
+  cerebras: CEREBRAS_CONFIG,
   cohere: COHERE_CONFIG,
   "fal-ai": FAL_AI_CONFIG,
   "fireworks-ai": FIREWORKS_AI_CONFIG,
   "hf-inference": HF_INFERENCE_CONFIG,
   hyperbolic: HYPERBOLIC_CONFIG,
+  openai: OPENAI_CONFIG,
   nebius: NEBIUS_CONFIG,
   novita: NOVITA_CONFIG,
   replicate: REPLICATE_CONFIG,
@@ -479,13 +533,36 @@ async function makeRequestOptions(args, options) {
   if (!providerConfig) {
     throw new Error(`No provider config found for provider ${provider}`);
   }
+  if (providerConfig.clientSideRoutingOnly && !maybeModel) {
+    throw new Error(`Provider ${provider} requires a model ID to be passed directly.`);
+  }
   const hfModel = maybeModel ?? await loadDefaultModel(task);
-  const model = await getProviderModelId({ model: hfModel, provider }, args, {
-    task,
-    chatCompletion: chatCompletion2,
-    fetch: options?.fetch
-  });
-  const authMethod = accessToken ? accessToken.startsWith("hf_") ? "hf-token" : "provider-key" : includeCredentials === "include" ? "credentials-include" : "none";
+  const model = providerConfig.clientSideRoutingOnly ? (
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    removeProviderPrefix(maybeModel, provider)
+  ) : (
+    // For closed-models API providers, one needs to pass the model ID directly (e.g. "gpt-3.5-turbo")
+    await getProviderModelId({ model: hfModel, provider }, args, {
+      task,
+      chatCompletion: chatCompletion2,
+      fetch: options?.fetch
+    })
+  );
+  const authMethod = (() => {
+    if (providerConfig.clientSideRoutingOnly) {
+      if (accessToken && accessToken.startsWith("hf_")) {
+        throw new Error(`Provider ${provider} is closed-source and does not support HF tokens.`);
+      }
+      return "provider-key";
+    }
+    if (accessToken) {
+      return accessToken.startsWith("hf_") ? "hf-token" : "provider-key";
+    }
+    if (includeCredentials === "include") {
+      return "credentials-include";
+    }
+    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,
     model,
@@ -543,6 +620,12 @@ async function loadTaskInfo() {
   }
   return await res.json();
 }
+function removeProviderPrefix(model, provider) {
+  if (!model.startsWith(`${provider}/`)) {
+    throw new Error(`Models from ${provider} must be prefixed by "${provider}/". Got "${model}".`);
+  }
+  return model.slice(provider.length + 1);
+}
 
 // src/tasks/custom/request.ts
 async function request(args, options) {
@@ -1542,6 +1625,7 @@ var HfInferenceEndpoint = class {
 // src/types.ts
 var INFERENCE_PROVIDERS = [
   "black-forest-labs",
+  "cerebras",
   "cohere",
   "fal-ai",
   "fireworks-ai",
@@ -1549,10 +1633,940 @@ var INFERENCE_PROVIDERS = [
   "hyperbolic",
   "nebius",
   "novita",
+  "openai",
   "replicate",
   "sambanova",
   "together"
 ];
+
+// src/snippets/index.ts
+var snippets_exports = {};
+__export(snippets_exports, {
+  curl: () => curl_exports,
+  js: () => js_exports,
+  python: () => python_exports
+});
+
+// src/snippets/curl.ts
+var curl_exports = {};
+__export(curl_exports, {
+  curlSnippets: () => curlSnippets,
+  getCurlInferenceSnippet: () => getCurlInferenceSnippet,
+  snippetBasic: () => snippetBasic,
+  snippetFile: () => snippetFile,
+  snippetTextGeneration: () => snippetTextGeneration,
+  snippetZeroShotClassification: () => snippetZeroShotClassification
+});
+var import_tasks = require("@huggingface/tasks");
+var import_tasks2 = require("@huggingface/tasks");
+var snippetBasic = (model, accessToken, provider) => {
+  if (provider !== "hf-inference") {
+    return [];
+  }
+  return [
+    {
+      client: "curl",
+      content: `curl https://router.huggingface.co/hf-inference/models/${model.id} \\
+	-X POST \\
+	-d '{"inputs": ${(0, import_tasks2.getModelInputSnippet)(model, true)}}' \\
+	-H 'Content-Type: application/json' \\
+	-H 'Authorization: Bearer ${accessToken || `{API_TOKEN}`}'`
+    }
+  ];
+};
+var snippetTextGeneration = (model, accessToken, provider, providerModelId, opts) => {
+  if (model.tags.includes("conversational")) {
+    const baseUrl = provider === "hf-inference" ? `https://router.huggingface.co/hf-inference/models/${model.id}/v1/chat/completions` : import_tasks.HF_HUB_INFERENCE_PROXY_TEMPLATE.replace("{{PROVIDER}}", provider) + "/v1/chat/completions";
+    const modelId = providerModelId ?? model.id;
+    const streaming = opts?.streaming ?? true;
+    const exampleMessages = (0, import_tasks2.getModelInputSnippet)(model);
+    const messages = opts?.messages ?? exampleMessages;
+    const config = {
+      ...opts?.temperature ? { temperature: opts.temperature } : void 0,
+      max_tokens: opts?.max_tokens ?? 500,
+      ...opts?.top_p ? { top_p: opts.top_p } : void 0
+    };
+    return [
+      {
+        client: "curl",
+        content: `curl '${baseUrl}' \\
+-H 'Authorization: Bearer ${accessToken || `{API_TOKEN}`}' \\
+-H 'Content-Type: application/json' \\
+--data '{
+    "model": "${modelId}",
+    "messages": ${(0, import_tasks2.stringifyMessages)(messages, {
+          indent: "	",
+          attributeKeyQuotes: true,
+          customContentEscaper: (str) => str.replace(/'/g, "'\\''")
+        })},
+    ${(0, import_tasks2.stringifyGenerationConfig)(config, {
+          indent: "\n    ",
+          attributeKeyQuotes: true,
+          attributeValueConnector: ": "
+        })}
+    "stream": ${!!streaming}
+}'`
+      }
+    ];
+  } else {
+    return snippetBasic(model, accessToken, provider);
+  }
+};
+var snippetZeroShotClassification = (model, accessToken, provider) => {
+  if (provider !== "hf-inference") {
+    return [];
+  }
+  return [
+    {
+      client: "curl",
+      content: `curl https://router.huggingface.co/hf-inference/models/${model.id} \\
+	-X POST \\
+	-d '{"inputs": ${(0, import_tasks2.getModelInputSnippet)(model, true)}, "parameters": {"candidate_labels": ["refund", "legal", "faq"]}}' \\
+	-H 'Content-Type: application/json' \\
+	-H 'Authorization: Bearer ${accessToken || `{API_TOKEN}`}'`
+    }
+  ];
+};
+var snippetFile = (model, accessToken, provider) => {
+  if (provider !== "hf-inference") {
+    return [];
+  }
+  return [
+    {
+      client: "curl",
+      content: `curl https://router.huggingface.co/hf-inference/models/${model.id} \\
+	-X POST \\
+	--data-binary '@${(0, import_tasks2.getModelInputSnippet)(model, true, true)}' \\
+	-H 'Authorization: Bearer ${accessToken || `{API_TOKEN}`}'`
+    }
+  ];
+};
+var curlSnippets = {
+  // Same order as in tasks/src/pipelines.ts
+  "text-classification": snippetBasic,
+  "token-classification": snippetBasic,
+  "table-question-answering": snippetBasic,
+  "question-answering": snippetBasic,
+  "zero-shot-classification": snippetZeroShotClassification,
+  translation: snippetBasic,
+  summarization: snippetBasic,
+  "feature-extraction": snippetBasic,
+  "text-generation": snippetTextGeneration,
+  "image-text-to-text": snippetTextGeneration,
+  "text2text-generation": snippetBasic,
+  "fill-mask": snippetBasic,
+  "sentence-similarity": snippetBasic,
+  "automatic-speech-recognition": snippetFile,
+  "text-to-image": snippetBasic,
+  "text-to-speech": snippetBasic,
+  "text-to-audio": snippetBasic,
+  "audio-to-audio": snippetFile,
+  "audio-classification": snippetFile,
+  "image-classification": snippetFile,
+  "image-to-text": snippetFile,
+  "object-detection": snippetFile,
+  "image-segmentation": snippetFile
+};
+function getCurlInferenceSnippet(model, accessToken, provider, providerModelId, opts) {
+  return model.pipeline_tag && model.pipeline_tag in curlSnippets ? curlSnippets[model.pipeline_tag]?.(model, accessToken, provider, providerModelId, opts) ?? [] : [];
+}
+
+// src/snippets/python.ts
+var python_exports = {};
+__export(python_exports, {
+  getPythonInferenceSnippet: () => getPythonInferenceSnippet,
+  pythonSnippets: () => pythonSnippets,
+  snippetBasic: () => snippetBasic2,
+  snippetConversational: () => snippetConversational,
+  snippetDocumentQuestionAnswering: () => snippetDocumentQuestionAnswering,
+  snippetFile: () => snippetFile2,
+  snippetTabular: () => snippetTabular,
+  snippetTextToAudio: () => snippetTextToAudio,
+  snippetTextToImage: () => snippetTextToImage,
+  snippetTextToVideo: () => snippetTextToVideo,
+  snippetZeroShotClassification: () => snippetZeroShotClassification2,
+  snippetZeroShotImageClassification: () => snippetZeroShotImageClassification
+});
+var import_tasks3 = require("@huggingface/tasks");
+var import_tasks4 = require("@huggingface/tasks");
+var HFH_INFERENCE_CLIENT_METHODS = {
+  "audio-classification": "audio_classification",
+  "audio-to-audio": "audio_to_audio",
+  "automatic-speech-recognition": "automatic_speech_recognition",
+  "text-to-speech": "text_to_speech",
+  "image-classification": "image_classification",
+  "image-segmentation": "image_segmentation",
+  "image-to-image": "image_to_image",
+  "image-to-text": "image_to_text",
+  "object-detection": "object_detection",
+  "text-to-image": "text_to_image",
+  "text-to-video": "text_to_video",
+  "zero-shot-image-classification": "zero_shot_image_classification",
+  "document-question-answering": "document_question_answering",
+  "visual-question-answering": "visual_question_answering",
+  "feature-extraction": "feature_extraction",
+  "fill-mask": "fill_mask",
+  "question-answering": "question_answering",
+  "sentence-similarity": "sentence_similarity",
+  summarization: "summarization",
+  "table-question-answering": "table_question_answering",
+  "text-classification": "text_classification",
+  "text-generation": "text_generation",
+  "token-classification": "token_classification",
+  translation: "translation",
+  "zero-shot-classification": "zero_shot_classification",
+  "tabular-classification": "tabular_classification",
+  "tabular-regression": "tabular_regression"
+};
+var snippetImportInferenceClient = (accessToken, provider) => `from huggingface_hub import InferenceClient
+
+client = InferenceClient(
+	provider="${provider}",
+	api_key="${accessToken || "{API_TOKEN}"}"
+)`;
+var snippetConversational = (model, accessToken, provider, providerModelId, opts) => {
+  const streaming = opts?.streaming ?? true;
+  const exampleMessages = (0, import_tasks4.getModelInputSnippet)(model);
+  const messages = opts?.messages ?? exampleMessages;
+  const messagesStr = (0, import_tasks4.stringifyMessages)(messages, { attributeKeyQuotes: true });
+  const config = {
+    ...opts?.temperature ? { temperature: opts.temperature } : void 0,
+    max_tokens: opts?.max_tokens ?? 500,
+    ...opts?.top_p ? { top_p: opts.top_p } : void 0
+  };
+  const configStr = (0, import_tasks4.stringifyGenerationConfig)(config, {
+    indent: "\n	",
+    attributeValueConnector: "="
+  });
+  if (streaming) {
+    return [
+      {
+        client: "huggingface_hub",
+        content: `${snippetImportInferenceClient(accessToken, provider)}
+
+messages = ${messagesStr}
+
+stream = client.chat.completions.create(
+	model="${model.id}", 
+	messages=messages, 
+	${configStr}
+	stream=True
+)
+
+for chunk in stream:
+    print(chunk.choices[0].delta.content, end="")`
+      },
+      {
+        client: "openai",
+        content: `from openai import OpenAI
+
+client = OpenAI(
+	base_url="${(0, import_tasks3.openAIbaseUrl)(provider)}",
+	api_key="${accessToken || "{API_TOKEN}"}"
+)
+
+messages = ${messagesStr}
+
+stream = client.chat.completions.create(
+    model="${providerModelId ?? model.id}", 
+	messages=messages, 
+	${configStr}
+	stream=True
+)
+
+for chunk in stream:
+	print(chunk.choices[0].delta.content, end="")`
+      }
+    ];
+  } else {
+    return [
+      {
+        client: "huggingface_hub",
+        content: `${snippetImportInferenceClient(accessToken, provider)}
+
+messages = ${messagesStr}
+
+completion = client.chat.completions.create(
+    model="${model.id}", 
+	messages=messages, 
+	${configStr}
+)
+
+print(completion.choices[0].message)`
+      },
+      {
+        client: "openai",
+        content: `from openai import OpenAI
+
+client = OpenAI(
+	base_url="${(0, import_tasks3.openAIbaseUrl)(provider)}",
+	api_key="${accessToken || "{API_TOKEN}"}"
+)
+
+messages = ${messagesStr}
+
+completion = client.chat.completions.create(
+	model="${providerModelId ?? model.id}", 
+	messages=messages, 
+	${configStr}
+)
+
+print(completion.choices[0].message)`
+      }
+    ];
+  }
+};
+var snippetZeroShotClassification2 = (model) => {
+  return [
+    {
+      client: "requests",
+      content: `def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.json()
+
+output = query({
+    "inputs": ${(0, import_tasks4.getModelInputSnippet)(model)},
+    "parameters": {"candidate_labels": ["refund", "legal", "faq"]},
+})`
+    }
+  ];
+};
+var snippetZeroShotImageClassification = (model) => {
+  return [
+    {
+      client: "requests",
+      content: `def query(data):
+	with open(data["image_path"], "rb") as f:
+		img = f.read()
+	payload={
+		"parameters": data["parameters"],
+		"inputs": base64.b64encode(img).decode("utf-8")
+	}
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.json()
+
+output = query({
+	"image_path": ${(0, import_tasks4.getModelInputSnippet)(model)},
+	"parameters": {"candidate_labels": ["cat", "dog", "llama"]},
+})`
+    }
+  ];
+};
+var snippetBasic2 = (model, accessToken, provider) => {
+  return [
+    ...model.pipeline_tag && model.pipeline_tag in HFH_INFERENCE_CLIENT_METHODS ? [
+      {
+        client: "huggingface_hub",
+        content: `${snippetImportInferenceClient(accessToken, provider)}
+
+result = client.${HFH_INFERENCE_CLIENT_METHODS[model.pipeline_tag]}(
+	model="${model.id}",
+	inputs=${(0, import_tasks4.getModelInputSnippet)(model)},
+	provider="${provider}",
+)
+
+print(result)
+`
+      }
+    ] : [],
+    {
+      client: "requests",
+      content: `def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.json()
+	
+output = query({
+	"inputs": ${(0, import_tasks4.getModelInputSnippet)(model)},
+})`
+    }
+  ];
+};
+var snippetFile2 = (model) => {
+  return [
+    {
+      client: "requests",
+      content: `def query(filename):
+	with open(filename, "rb") as f:
+		data = f.read()
+	response = requests.post(API_URL, headers=headers, data=data)
+	return response.json()
+
+output = query(${(0, import_tasks4.getModelInputSnippet)(model)})`
+    }
+  ];
+};
+var snippetTextToImage = (model, accessToken, provider, providerModelId) => {
+  return [
+    {
+      client: "huggingface_hub",
+      content: `${snippetImportInferenceClient(accessToken, provider)}
+
+# output is a PIL.Image object
+image = client.text_to_image(
+	${(0, import_tasks4.getModelInputSnippet)(model)},
+	model="${model.id}"
+)`
+    },
+    ...provider === "fal-ai" ? [
+      {
+        client: "fal-client",
+        content: `import fal_client
+
+result = fal_client.subscribe(
+	"${providerModelId ?? model.id}",
+	arguments={
+		"prompt": ${(0, import_tasks4.getModelInputSnippet)(model)},
+	},
+)
+print(result)
+`
+      }
+    ] : [],
+    ...provider === "hf-inference" ? [
+      {
+        client: "requests",
+        content: `def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.content
+
+image_bytes = query({
+	"inputs": ${(0, import_tasks4.getModelInputSnippet)(model)},
+})
+
+# You can access the image with PIL.Image for example
+import io
+from PIL import Image
+image = Image.open(io.BytesIO(image_bytes))`
+      }
+    ] : []
+  ];
+};
+var snippetTextToVideo = (model, accessToken, provider) => {
+  return ["fal-ai", "replicate"].includes(provider) ? [
+    {
+      client: "huggingface_hub",
+      content: `${snippetImportInferenceClient(accessToken, provider)}
+
+video = client.text_to_video(
+	${(0, import_tasks4.getModelInputSnippet)(model)},
+	model="${model.id}"
+)`
+    }
+  ] : [];
+};
+var snippetTabular = (model) => {
+  return [
+    {
+      client: "requests",
+      content: `def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.content
+
+response = query({
+	"inputs": {"data": ${(0, import_tasks4.getModelInputSnippet)(model)}},
+})`
+    }
+  ];
+};
+var snippetTextToAudio = (model) => {
+  if (model.library_name === "transformers") {
+    return [
+      {
+        client: "requests",
+        content: `def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.content
+
+audio_bytes = query({
+	"inputs": ${(0, import_tasks4.getModelInputSnippet)(model)},
+})
+# You can access the audio with IPython.display for example
+from IPython.display import Audio
+Audio(audio_bytes)`
+      }
+    ];
+  } else {
+    return [
+      {
+        client: "requests",
+        content: `def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.json()
+	
+audio, sampling_rate = query({
+	"inputs": ${(0, import_tasks4.getModelInputSnippet)(model)},
+})
+# You can access the audio with IPython.display for example
+from IPython.display import Audio
+Audio(audio, rate=sampling_rate)`
+      }
+    ];
+  }
+};
+var snippetDocumentQuestionAnswering = (model) => {
+  return [
+    {
+      client: "requests",
+      content: `def query(payload):
+	with open(payload["image"], "rb") as f:
+		img = f.read()
+		payload["image"] = base64.b64encode(img).decode("utf-8")  
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.json()
+
+output = query({
+    "inputs": ${(0, import_tasks4.getModelInputSnippet)(model)},
+})`
+    }
+  ];
+};
+var pythonSnippets = {
+  // Same order as in tasks/src/pipelines.ts
+  "text-classification": snippetBasic2,
+  "token-classification": snippetBasic2,
+  "table-question-answering": snippetBasic2,
+  "question-answering": snippetBasic2,
+  "zero-shot-classification": snippetZeroShotClassification2,
+  translation: snippetBasic2,
+  summarization: snippetBasic2,
+  "feature-extraction": snippetBasic2,
+  "text-generation": snippetBasic2,
+  "text2text-generation": snippetBasic2,
+  "image-text-to-text": snippetConversational,
+  "fill-mask": snippetBasic2,
+  "sentence-similarity": snippetBasic2,
+  "automatic-speech-recognition": snippetFile2,
+  "text-to-image": snippetTextToImage,
+  "text-to-video": snippetTextToVideo,
+  "text-to-speech": snippetTextToAudio,
+  "text-to-audio": snippetTextToAudio,
+  "audio-to-audio": snippetFile2,
+  "audio-classification": snippetFile2,
+  "image-classification": snippetFile2,
+  "tabular-regression": snippetTabular,
+  "tabular-classification": snippetTabular,
+  "object-detection": snippetFile2,
+  "image-segmentation": snippetFile2,
+  "document-question-answering": snippetDocumentQuestionAnswering,
+  "image-to-text": snippetFile2,
+  "zero-shot-image-classification": snippetZeroShotImageClassification
+};
+function getPythonInferenceSnippet(model, accessToken, provider, providerModelId, opts) {
+  if (model.tags.includes("conversational")) {
+    return snippetConversational(model, accessToken, provider, providerModelId, opts);
+  } else {
+    const snippets = model.pipeline_tag && model.pipeline_tag in pythonSnippets ? pythonSnippets[model.pipeline_tag]?.(model, accessToken, provider, providerModelId) ?? [] : [];
+    return snippets.map((snippet) => {
+      return {
+        ...snippet,
+        content: snippet.client === "requests" ? `import requests
+
+API_URL = "${(0, import_tasks3.openAIbaseUrl)(provider)}"
+headers = {"Authorization": ${accessToken ? `"Bearer ${accessToken}"` : `f"Bearer {API_TOKEN}"`}}
+
+${snippet.content}` : snippet.content
+      };
+    });
+  }
+}
+
+// src/snippets/js.ts
+var js_exports = {};
+__export(js_exports, {
+  getJsInferenceSnippet: () => getJsInferenceSnippet,
+  jsSnippets: () => jsSnippets,
+  snippetAutomaticSpeechRecognition: () => snippetAutomaticSpeechRecognition,
+  snippetBasic: () => snippetBasic3,
+  snippetFile: () => snippetFile3,
+  snippetTextGeneration: () => snippetTextGeneration2,
+  snippetTextToAudio: () => snippetTextToAudio2,
+  snippetTextToImage: () => snippetTextToImage2,
+  snippetTextToVideo: () => snippetTextToVideo2,
+  snippetZeroShotClassification: () => snippetZeroShotClassification3
+});
+var import_tasks5 = require("@huggingface/tasks");
+var import_tasks6 = require("@huggingface/tasks");
+var HFJS_METHODS = {
+  "text-classification": "textClassification",
+  "token-classification": "tokenClassification",
+  "table-question-answering": "tableQuestionAnswering",
+  "question-answering": "questionAnswering",
+  translation: "translation",
+  summarization: "summarization",
+  "feature-extraction": "featureExtraction",
+  "text-generation": "textGeneration",
+  "text2text-generation": "textGeneration",
+  "fill-mask": "fillMask",
+  "sentence-similarity": "sentenceSimilarity"
+};
+var snippetBasic3 = (model, accessToken, provider) => {
+  return [
+    ...model.pipeline_tag && model.pipeline_tag in HFJS_METHODS ? [
+      {
+        client: "huggingface.js",
+        content: `import { HfInference } from "@huggingface/inference";
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}");
+
+const output = await client.${HFJS_METHODS[model.pipeline_tag]}({
+	model: "${model.id}",
+	inputs: ${(0, import_tasks6.getModelInputSnippet)(model)},
+	provider: "${provider}",
+});
+
+console.log(output);
+`
+      }
+    ] : [],
+    {
+      client: "fetch",
+      content: `async function query(data) {
+	const response = await fetch(
+		"https://router.huggingface.co/hf-inference/models/${model.id}",
+		{
+			headers: {
+				Authorization: "Bearer ${accessToken || `{API_TOKEN}`}",
+				"Content-Type": "application/json",
+			},
+			method: "POST",
+			body: JSON.stringify(data),
+		}
+	);
+	const result = await response.json();
+	return result;
+}
+
+query({"inputs": ${(0, import_tasks6.getModelInputSnippet)(model)}}).then((response) => {
+	console.log(JSON.stringify(response));
+});`
+    }
+  ];
+};
+var snippetTextGeneration2 = (model, accessToken, provider, providerModelId, opts) => {
+  if (model.tags.includes("conversational")) {
+    const streaming = opts?.streaming ?? true;
+    const exampleMessages = (0, import_tasks6.getModelInputSnippet)(model);
+    const messages = opts?.messages ?? exampleMessages;
+    const messagesStr = (0, import_tasks6.stringifyMessages)(messages, { indent: "	" });
+    const config = {
+      ...opts?.temperature ? { temperature: opts.temperature } : void 0,
+      max_tokens: opts?.max_tokens ?? 500,
+      ...opts?.top_p ? { top_p: opts.top_p } : void 0
+    };
+    const configStr = (0, import_tasks6.stringifyGenerationConfig)(config, {
+      indent: "\n	",
+      attributeValueConnector: ": "
+    });
+    if (streaming) {
+      return [
+        {
+          client: "huggingface.js",
+          content: `import { HfInference } from "@huggingface/inference";
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}");
+
+let out = "";
+
+const stream = client.chatCompletionStream({
+	model: "${model.id}",
+	messages: ${messagesStr},
+	provider: "${provider}",
+	${configStr}
+});
+
+for await (const chunk of stream) {
+	if (chunk.choices && chunk.choices.length > 0) {
+		const newContent = chunk.choices[0].delta.content;
+		out += newContent;
+		console.log(newContent);
+	}  
+}`
+        },
+        {
+          client: "openai",
+          content: `import { OpenAI } from "openai";
+
+const client = new OpenAI({
+	baseURL: "${(0, import_tasks5.openAIbaseUrl)(provider)}",
+	apiKey: "${accessToken || `{API_TOKEN}`}"
+});
+
+let out = "";
+
+const stream = await client.chat.completions.create({
+	model: "${providerModelId ?? model.id}",
+	messages: ${messagesStr},
+	${configStr}
+	stream: true,
+});
+
+for await (const chunk of stream) {
+	if (chunk.choices && chunk.choices.length > 0) {
+		const newContent = chunk.choices[0].delta.content;
+		out += newContent;
+		console.log(newContent);
+	}  
+}`
+        }
+      ];
+    } else {
+      return [
+        {
+          client: "huggingface.js",
+          content: `import { HfInference } from "@huggingface/inference";
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}");
+
+const chatCompletion = await client.chatCompletion({
+	model: "${model.id}",
+	messages: ${messagesStr},
+	provider: "${provider}",
+	${configStr}
+});
+
+console.log(chatCompletion.choices[0].message);
+`
+        },
+        {
+          client: "openai",
+          content: `import { OpenAI } from "openai";
+
+const client = new OpenAI({
+	baseURL: "${(0, import_tasks5.openAIbaseUrl)(provider)}",
+	apiKey: "${accessToken || `{API_TOKEN}`}"
+});
+
+const chatCompletion = await client.chat.completions.create({
+	model: "${providerModelId ?? model.id}",
+	messages: ${messagesStr},
+	${configStr}
+});
+
+console.log(chatCompletion.choices[0].message);
+`
+        }
+      ];
+    }
+  } else {
+    return snippetBasic3(model, accessToken, provider);
+  }
+};
+var snippetZeroShotClassification3 = (model, accessToken) => {
+  return [
+    {
+      client: "fetch",
+      content: `async function query(data) {
+			const response = await fetch(
+				"https://router.huggingface.co/hf-inference/models/${model.id}",
+				{
+					headers: {
+						Authorization: "Bearer ${accessToken || `{API_TOKEN}`}",
+						"Content-Type": "application/json",
+					},
+					method: "POST",
+					body: JSON.stringify(data),
+				}
+			);
+			const result = await response.json();
+			return result;
+		}
+		
+		query({"inputs": ${(0, import_tasks6.getModelInputSnippet)(
+        model
+      )}, "parameters": {"candidate_labels": ["refund", "legal", "faq"]}}).then((response) => {
+			console.log(JSON.stringify(response));
+		});`
+    }
+  ];
+};
+var snippetTextToImage2 = (model, accessToken, provider) => {
+  return [
+    {
+      client: "huggingface.js",
+      content: `import { HfInference } from "@huggingface/inference";
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}");
+
+const image = await client.textToImage({
+	model: "${model.id}",
+	inputs: ${(0, import_tasks6.getModelInputSnippet)(model)},
+	parameters: { num_inference_steps: 5 },
+	provider: "${provider}",
+});
+/// Use the generated image (it's a Blob)
+`
+    },
+    ...provider === "hf-inference" ? [
+      {
+        client: "fetch",
+        content: `async function query(data) {
+	const response = await fetch(
+		"https://router.huggingface.co/hf-inference/models/${model.id}",
+		{
+			headers: {
+				Authorization: "Bearer ${accessToken || `{API_TOKEN}`}",
+				"Content-Type": "application/json",
+			},
+			method: "POST",
+			body: JSON.stringify(data),
+		}
+	);
+	const result = await response.blob();
+	return result;
+}
+query({"inputs": ${(0, import_tasks6.getModelInputSnippet)(model)}}).then((response) => {
+	// Use image
+});`
+      }
+    ] : []
+  ];
+};
+var snippetTextToVideo2 = (model, accessToken, provider) => {
+  return ["fal-ai", "replicate"].includes(provider) ? [
+    {
+      client: "huggingface.js",
+      content: `import { HfInference } from "@huggingface/inference";
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}");
+
+const video = await client.textToVideo({
+	model: "${model.id}",
+	provider: "${provider}",
+	inputs: ${(0, import_tasks6.getModelInputSnippet)(model)},
+	parameters: { num_inference_steps: 5 },
+});
+// Use the generated video (it's a Blob)
+`
+    }
+  ] : [];
+};
+var snippetTextToAudio2 = (model, accessToken, provider) => {
+  if (provider !== "hf-inference") {
+    return [];
+  }
+  const commonSnippet = `async function query(data) {
+		const response = await fetch(
+			"https://router.huggingface.co/hf-inference/models/${model.id}",
+			{
+				headers: {
+					Authorization: "Bearer ${accessToken || `{API_TOKEN}`}",
+					"Content-Type": "application/json",
+				},
+				method: "POST",
+				body: JSON.stringify(data),
+			}
+		);`;
+  if (model.library_name === "transformers") {
+    return [
+      {
+        client: "fetch",
+        content: commonSnippet + `
+			const result = await response.blob();
+			return result;
+		}
+		query({"inputs": ${(0, import_tasks6.getModelInputSnippet)(model)}}).then((response) => {
+			// Returns a byte object of the Audio wavform. Use it directly!
+		});`
+      }
+    ];
+  } else {
+    return [
+      {
+        client: "fetch",
+        content: commonSnippet + `
+			const result = await response.json();
+			return result;
+		}
+		
+		query({"inputs": ${(0, import_tasks6.getModelInputSnippet)(model)}}).then((response) => {
+			console.log(JSON.stringify(response));
+		});`
+      }
+    ];
+  }
+};
+var snippetAutomaticSpeechRecognition = (model, accessToken, provider) => {
+  return [
+    {
+      client: "huggingface.js",
+      content: `import { HfInference } from "@huggingface/inference";
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}");
+
+const data = fs.readFileSync(${(0, import_tasks6.getModelInputSnippet)(model)});
+
+const output = await client.automaticSpeechRecognition({
+	data,
+	model: "${model.id}",
+	provider: "${provider}",
+});
+
+console.log(output);
+`
+    },
+    ...provider === "hf-inference" ? snippetFile3(model, accessToken, provider) : []
+  ];
+};
+var snippetFile3 = (model, accessToken, provider) => {
+  if (provider !== "hf-inference") {
+    return [];
+  }
+  return [
+    {
+      client: "fetch",
+      content: `async function query(filename) {
+	const data = fs.readFileSync(filename);
+	const response = await fetch(
+		"https://router.huggingface.co/hf-inference/models/${model.id}",
+		{
+			headers: {
+				Authorization: "Bearer ${accessToken || `{API_TOKEN}`}",
+				"Content-Type": "application/json",
+			},
+			method: "POST",
+			body: data,
+		}
+	);
+	const result = await response.json();
+	return result;
+}
+
+query(${(0, import_tasks6.getModelInputSnippet)(model)}).then((response) => {
+	console.log(JSON.stringify(response));
+});`
+    }
+  ];
+};
+var jsSnippets = {
+  // Same order as in tasks/src/pipelines.ts
+  "text-classification": snippetBasic3,
+  "token-classification": snippetBasic3,
+  "table-question-answering": snippetBasic3,
+  "question-answering": snippetBasic3,
+  "zero-shot-classification": snippetZeroShotClassification3,
+  translation: snippetBasic3,
+  summarization: snippetBasic3,
+  "feature-extraction": snippetBasic3,
+  "text-generation": snippetTextGeneration2,
+  "image-text-to-text": snippetTextGeneration2,
+  "text2text-generation": snippetBasic3,
+  "fill-mask": snippetBasic3,
+  "sentence-similarity": snippetBasic3,
+  "automatic-speech-recognition": snippetAutomaticSpeechRecognition,
+  "text-to-image": snippetTextToImage2,
+  "text-to-video": snippetTextToVideo2,
+  "text-to-speech": snippetTextToAudio2,
+  "text-to-audio": snippetTextToAudio2,
+  "audio-to-audio": snippetFile3,
+  "audio-classification": snippetFile3,
+  "image-classification": snippetFile3,
+  "image-to-text": snippetFile3,
+  "object-detection": snippetFile3,
+  "image-segmentation": snippetFile3
+};
+function getJsInferenceSnippet(model, accessToken, provider, providerModelId, opts) {
+  return model.pipeline_tag && model.pipeline_tag in jsSnippets ? jsSnippets[model.pipeline_tag]?.(model, accessToken, provider, providerModelId, opts) ?? [] : [];
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HfInference,
@@ -1575,6 +2589,7 @@ var INFERENCE_PROVIDERS = [
   questionAnswering,
   request,
   sentenceSimilarity,
+  snippets,
   streamingRequest,
   summarization,
   tableQuestionAnswering,