@workglow/huggingface-inference 0.2.28

package/dist/ai-provider-runtime.js

@@ -0,0 +1,670 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/ai-provider/common/HFI_Client.ts
+var _sdk;
+async function loadHfInferenceSDK() {
+  if (!_sdk) {
+    try {
+      _sdk = await import("@huggingface/inference");
+    } catch {
+      throw new Error("@huggingface/inference is required for Hugging Face Inference tasks. Install it with: bun add @huggingface/inference");
+    }
+  }
+  return _sdk;
+}
+async function getClient(model) {
+  const sdk = await loadHfInferenceSDK();
+  const config = model?.provider_config;
+  const apiKey = config?.credential_key || config?.api_key || (typeof process !== "undefined" ? process.env?.HF_TOKEN : undefined);
+  if (!apiKey) {
+    throw new Error("Missing Hugging Face API key: set provider_config.credential_key or the HF_TOKEN environment variable.");
+  }
+  try {
+    return new sdk.InferenceClient(apiKey);
+  } catch (err) {
+    throw new Error(`Failed to create HuggingFace Inference client: ${err instanceof Error ? err.message : "unknown error"}`);
+  }
+}
+function getModelName(model) {
+  const name = model?.provider_config?.model_name;
+  if (!name) {
+    throw new Error("Missing model name in provider_config.model_name.");
+  }
+  return name;
+}
+function getProvider(model) {
+  return model?.provider_config?.provider;
+}
+
+// src/ai-provider/registerHfInferenceInline.ts
+import { registerProviderInline } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/HFI_ModelSearch.ts
+import { mapHfModelResult, searchHfModels } from "@workglow/ai-provider/common";
+import { filterLabeledModelsByQuery } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/HFI_Constants.ts
+var HF_INFERENCE = "HF_INFERENCE";
+
+// src/ai-provider/common/HFI_ModelSearch.ts
+var HFI_IMAGE_MODELS = [
+  { id: "black-forest-labs/FLUX.1-schnell", tasks: ["ImageGenerateTask"] },
+  { id: "black-forest-labs/FLUX.1-Kontext-dev", tasks: ["ImageEditTask"] }
+];
+function buildFallbackResults() {
+  return HFI_IMAGE_MODELS.map((m) => ({
+    id: m.id,
+    label: m.id,
+    description: "",
+    record: {
+      model_id: m.id,
+      provider: HF_INFERENCE,
+      title: m.id.split("/").pop() ?? m.id,
+      description: "",
+      tasks: m.tasks,
+      provider_config: { model_name: m.id },
+      metadata: {}
+    },
+    raw: m
+  }));
+}
+var HFI_ModelSearch = async (input, _model, _onProgress, signal) => {
+  const query = input.query?.trim() ?? "";
+  if (!input.credential_key) {
+    const fallback = buildFallbackResults();
+    const labeled = fallback.map((r) => ({ label: r.label, value: r.id }));
+    const filtered = filterLabeledModelsByQuery(labeled, query).map((m) => fallback.find((r) => r.id === m.value));
+    return { results: filtered };
+  }
+  const entries = await searchHfModels(query, undefined, undefined, signal, input.credential_key);
+  const results = entries.map((entry) => {
+    const imageEntry = HFI_IMAGE_MODELS.find((m) => m.id === entry.id);
+    const mapped = mapHfModelResult(entry, HF_INFERENCE);
+    if (imageEntry) {
+      mapped.record.tasks = imageEntry.tasks;
+    }
+    return mapped;
+  });
+  return { results };
+};
+
+// src/ai-provider/common/HFI_ImageEdit.ts
+import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
+import { getLogger } from "@workglow/util/worker";
+import { blobToImageValue, imageValueToPngBytes } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/HFI_AspectRatio.ts
+var FLUX_DIMS = {
+  "1:1": { width: 1024, height: 1024 },
+  "16:9": { width: 1344, height: 768 },
+  "9:16": { width: 768, height: 1344 },
+  "4:3": { width: 1152, height: 896 },
+  "3:4": { width: 896, height: 1152 }
+};
+var SDXL_DIMS = {
+  "1:1": { width: 1024, height: 1024 },
+  "16:9": { width: 1280, height: 720 },
+  "9:16": { width: 720, height: 1280 },
+  "4:3": { width: 1024, height: 768 },
+  "3:4": { width: 768, height: 1024 }
+};
+var DEFAULT_DIMS = SDXL_DIMS;
+var MODEL_DIM_TABLE = [
+  { pattern: /^black-forest-labs\/FLUX/i, dims: FLUX_DIMS },
+  { pattern: /^stabilityai\/.*-xl/i, dims: SDXL_DIMS }
+];
+function resolveHfImageDims(modelId, aspectRatio) {
+  const entry = MODEL_DIM_TABLE.find((e) => e.pattern.test(modelId));
+  return (entry?.dims ?? DEFAULT_DIMS)[aspectRatio];
+}
+function isHfInpaintingModel(modelId) {
+  return /inpaint|kontext/i.test(modelId);
+}
+
+// src/ai-provider/common/HFI_ImageEdit.ts
+function modelIdOf(model) {
+  return model?.model_id ?? model?.provider_config?.model_name ?? "huggingface";
+}
+async function gpuImageToBlob(image) {
+  const bytes = await imageValueToPngBytes(image);
+  const buffer = bytes.buffer instanceof ArrayBuffer ? bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) : new Uint8Array(bytes).buffer;
+  return new Blob([buffer], { type: "image/png" });
+}
+var HFI_ImageEdit = async (input, model, update_progress, signal) => {
+  const logger = getLogger();
+  const timer = `hfi:ImageEdit:${getModelName(model)}`;
+  logger.time(timer);
+  update_progress(0, "Starting HF image edit");
+  try {
+    const client = await getClient(model);
+    const modelName = getModelName(model);
+    const dims = resolveHfImageDims(modelName, input.aspectRatio ?? "1:1");
+    const inputBlob = await gpuImageToBlob(input.image);
+    const params = {
+      width: dims.width,
+      height: dims.height,
+      seed: input.seed,
+      negative_prompt: input.negativePrompt,
+      prompt: input.prompt,
+      ...input.providerOptions ?? {}
+    };
+    if (input.mask) {
+      const maskBlob = await gpuImageToBlob(input.mask);
+      params.mask_image = maskBlob;
+    }
+    const blob = await client.imageToImage({
+      model: modelName,
+      inputs: inputBlob,
+      parameters: params
+    }, { signal });
+    const image = await blobToImageValue(blob);
+    update_progress(100, "Completed HF image edit");
+    logger.timeEnd(timer);
+    return { image };
+  } catch (err) {
+    if (err instanceof ImageGenerationProviderError || err instanceof ImageGenerationContentPolicyError)
+      throw err;
+    const msg = err instanceof Error ? err.message : "unknown error";
+    if (/NSFW|safety|policy/i.test(msg))
+      throw new ImageGenerationContentPolicyError(modelIdOf(model), msg);
+    throw new ImageGenerationProviderError(modelIdOf(model), msg, { cause: err });
+  }
+};
+var HFI_ImageEdit_Stream = async function* (input, model, signal) {
+  const result = await HFI_ImageEdit(input, model, () => {}, signal);
+  if (signal.aborted)
+    return;
+  yield { type: "snapshot", data: result };
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFI_ImageGenerate.ts
+import { ImageGenerationContentPolicyError as ImageGenerationContentPolicyError2, ImageGenerationProviderError as ImageGenerationProviderError2 } from "@workglow/ai";
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+import { blobToImageValue as blobToImageValue2 } from "@workglow/ai-provider/common";
+function modelIdOf2(model) {
+  return model?.model_id ?? model?.provider_config?.model_name ?? "huggingface";
+}
+var HFI_ImageGenerate = async (input, model, update_progress, signal) => {
+  const logger = getLogger2();
+  const timer = `hfi:ImageGenerate:${getModelName(model)}`;
+  logger.time(timer);
+  update_progress(0, "Starting HF image generation");
+  try {
+    const client = await getClient(model);
+    const modelName = getModelName(model);
+    const dims = resolveHfImageDims(modelName, input.aspectRatio ?? "1:1");
+    const blob = await client.textToImage({
+      model: modelName,
+      inputs: input.prompt,
+      parameters: {
+        width: dims.width,
+        height: dims.height,
+        seed: input.seed,
+        negative_prompt: input.negativePrompt,
+        ...input.providerOptions ?? {}
+      }
+    }, { outputType: "blob", signal });
+    const image = await blobToImageValue2(blob);
+    update_progress(100, "Completed HF image generation");
+    logger.timeEnd(timer);
+    return { image };
+  } catch (err) {
+    if (err instanceof ImageGenerationProviderError2 || err instanceof ImageGenerationContentPolicyError2)
+      throw err;
+    const msg = err instanceof Error ? err.message : "unknown error";
+    if (/NSFW|safety|policy/i.test(msg))
+      throw new ImageGenerationContentPolicyError2(modelIdOf2(model), msg);
+    throw new ImageGenerationProviderError2(modelIdOf2(model), msg, { cause: err });
+  }
+};
+var HFI_ImageGenerate_Stream = async function* (input, model, signal) {
+  const result = await HFI_ImageGenerate(input, model, () => {}, signal);
+  if (signal.aborted)
+    return;
+  yield { type: "snapshot", data: result };
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFI_ModelInfo.ts
+var HFI_ModelInfo = async (input, model) => {
+  if (input.detail === "dimensions") {
+    const pc = model?.provider_config;
+    const native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
+    const mrl = typeof pc?.mrl === "boolean" ? pc.mrl : false;
+    return {
+      model: input.model,
+      is_local: false,
+      is_remote: true,
+      supports_browser: true,
+      supports_node: true,
+      is_cached: false,
+      is_loaded: false,
+      file_sizes: null,
+      ...native_dimensions !== undefined ? { native_dimensions } : {},
+      ...mrl ? { mrl } : {}
+    };
+  }
+  return {
+    model: input.model,
+    is_local: false,
+    is_remote: true,
+    supports_browser: true,
+    supports_node: true,
+    is_cached: false,
+    is_loaded: false,
+    file_sizes: null
+  };
+};
+
+// src/ai-provider/common/HFI_TextEmbedding.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+var HFI_TextEmbedding = async (input, model, update_progress, signal) => {
+  const logger = getLogger3();
+  const timerLabel = `hfi:TextEmbedding:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  update_progress(0, "Starting HF Inference text embedding");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  if (Array.isArray(input.text)) {
+    const embeddings = await Promise.all(input.text.map((text) => client.featureExtraction({
+      model: modelName,
+      inputs: text
+    }, { signal })));
+    update_progress(100, "Completed HF Inference text embedding");
+    logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name, batch: true });
+    return {
+      vector: embeddings.map((embedding2) => new Float32Array(embedding2))
+    };
+  }
+  const embedding = await client.featureExtraction({
+    model: modelName,
+    inputs: input.text
+  }, { signal });
+  update_progress(100, "Completed HF Inference text embedding");
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  return { vector: new Float32Array(embedding) };
+};
+
+// src/ai-provider/common/HFI_TextGeneration.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+var HFI_TextGeneration = async (input, model, update_progress, signal) => {
+  const logger = getLogger4();
+  const timerLabel = `hfi:TextGeneration:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  update_progress(0, "Starting HF Inference text generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const response = await client.chatCompletion({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    top_p: input.topP,
+    frequency_penalty: input.frequencyPenalty,
+    provider
+  }, { signal });
+  update_progress(100, "Completed HF Inference text generation");
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var HFI_TextGeneration_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const stream = client.chatCompletionStream({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    top_p: input.topP,
+    frequency_penalty: input.frequencyPenalty,
+    provider
+  }, { signal });
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content ?? "";
+    if (delta) {
+      yield { type: "text-delta", port: "text", textDelta: delta };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFI_TextRewriter.ts
+var HFI_TextRewriter = async (input, model, update_progress, signal) => {
+  update_progress(0, "Starting HF Inference text rewriting");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const response = await client.chatCompletion({
+    model: modelName,
+    messages: [
+      { role: "system", content: input.prompt },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  update_progress(100, "Completed HF Inference text rewriting");
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var HFI_TextRewriter_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const stream = client.chatCompletionStream({
+    model: modelName,
+    messages: [
+      { role: "system", content: input.prompt },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content ?? "";
+    if (delta) {
+      yield { type: "text-delta", port: "text", textDelta: delta };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFI_TextSummary.ts
+var HFI_TextSummary = async (input, model, update_progress, signal) => {
+  update_progress(0, "Starting HF Inference text summarization");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const response = await client.chatCompletion({
+    model: modelName,
+    messages: [
+      { role: "system", content: "Summarize the following text concisely." },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  update_progress(100, "Completed HF Inference text summarization");
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var HFI_TextSummary_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const stream = client.chatCompletionStream({
+    model: modelName,
+    messages: [
+      { role: "system", content: "Summarize the following text concisely." },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content ?? "";
+    if (delta) {
+      yield { type: "text-delta", port: "text", textDelta: delta };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFI_ToolCalling.ts
+import { buildToolDescription, filterValidToolCalls, toOpenAIMessages } from "@workglow/ai/worker";
+import { parsePartialJson } from "@workglow/util/worker";
+function mapHFIToolChoice(toolChoice) {
+  if (!toolChoice || toolChoice === "auto")
+    return "auto";
+  if (toolChoice === "none")
+    return "none";
+  if (toolChoice === "required")
+    return "required";
+  return "auto";
+}
+var HFI_ToolCalling = async (input, model, update_progress, signal) => {
+  update_progress(0, "Starting HF Inference tool calling");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const tools = input.tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+  const messages = toOpenAIMessages(input);
+  const toolChoice = mapHFIToolChoice(input.toolChoice);
+  const params = {
+    model: modelName,
+    messages,
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    provider
+  };
+  if (toolChoice !== "none") {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  const response = await client.chatCompletion(params, { signal });
+  const text = response.choices[0]?.message?.content ?? "";
+  const toolCalls = [];
+  let callIndex = 0;
+  (response.choices[0]?.message?.tool_calls ?? []).forEach((tc) => {
+    let parsedInput = {};
+    const rawArgs = tc.function?.arguments;
+    if (typeof rawArgs === "string") {
+      try {
+        parsedInput = JSON.parse(rawArgs);
+      } catch {
+        const partial = parsePartialJson(rawArgs);
+        parsedInput = partial ?? {};
+      }
+    } else if (rawArgs != null) {
+      parsedInput = rawArgs;
+    }
+    const id = tc.id ?? `call_${callIndex}`;
+    callIndex++;
+    toolCalls.push({ id, name: tc.function.name, input: parsedInput });
+  });
+  update_progress(100, "Completed HF Inference tool calling");
+  return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
+};
+var HFI_ToolCalling_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const tools = input.tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+  const messages = toOpenAIMessages(input);
+  const toolChoice = mapHFIToolChoice(input.toolChoice);
+  const params = {
+    model: modelName,
+    messages,
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    provider
+  };
+  if (toolChoice !== "none") {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  const stream = client.chatCompletionStream(params, { signal });
+  let accumulatedText = "";
+  const toolCallAccumulator = new Map;
+  for await (const chunk of stream) {
+    const choice = chunk.choices[0];
+    if (!choice)
+      continue;
+    const contentDelta = choice.delta?.content ?? "";
+    if (contentDelta) {
+      accumulatedText += contentDelta;
+      yield { type: "text-delta", port: "text", textDelta: contentDelta };
+    }
+    const tcDeltas = choice.delta?.tool_calls;
+    if (Array.isArray(tcDeltas)) {
+      for (const tcDelta of tcDeltas) {
+        const idx = tcDelta.index;
+        if (!toolCallAccumulator.has(idx)) {
+          toolCallAccumulator.set(idx, {
+            id: tcDelta.id ?? "",
+            name: tcDelta.function?.name ?? "",
+            arguments: ""
+          });
+        }
+        const acc = toolCallAccumulator.get(idx);
+        if (tcDelta.id)
+          acc.id = tcDelta.id;
+        if (tcDelta.function?.name)
+          acc.name = tcDelta.function.name;
+        if (tcDelta.function?.arguments)
+          acc.arguments += tcDelta.function.arguments;
+      }
+      const snapshot = [];
+      for (const [, tc] of toolCallAccumulator) {
+        let parsedInput;
+        try {
+          parsedInput = JSON.parse(tc.arguments);
+        } catch {
+          const partial = parsePartialJson(tc.arguments);
+          parsedInput = partial ?? {};
+        }
+        snapshot.push({ id: tc.id, name: tc.name, input: parsedInput });
+      }
+      yield { type: "object-delta", port: "toolCalls", objectDelta: snapshot };
+    }
+  }
+  const toolCalls = [];
+  for (const [, tc] of toolCallAccumulator) {
+    let finalInput;
+    try {
+      finalInput = JSON.parse(tc.arguments);
+    } catch {
+      finalInput = parsePartialJson(tc.arguments) ?? {};
+    }
+    toolCalls.push({ id: tc.id, name: tc.name, input: finalInput });
+  }
+  const validToolCalls = filterValidToolCalls(toolCalls, input.tools);
+  yield {
+    type: "finish",
+    data: { text: accumulatedText, toolCalls: validToolCalls }
+  };
+};
+
+// src/ai-provider/common/HFI_JobRunFns.ts
+var HFI_TASKS = {
+  ModelInfoTask: HFI_ModelInfo,
+  TextGenerationTask: HFI_TextGeneration,
+  TextEmbeddingTask: HFI_TextEmbedding,
+  TextRewriterTask: HFI_TextRewriter,
+  TextSummaryTask: HFI_TextSummary,
+  ToolCallingTask: HFI_ToolCalling,
+  ModelSearchTask: HFI_ModelSearch,
+  ImageGenerateTask: HFI_ImageGenerate,
+  ImageEditTask: HFI_ImageEdit
+};
+var HFI_STREAM_TASKS = {
+  TextGenerationTask: HFI_TextGeneration_Stream,
+  TextRewriterTask: HFI_TextRewriter_Stream,
+  TextSummaryTask: HFI_TextSummary_Stream,
+  ToolCallingTask: HFI_ToolCalling_Stream,
+  ImageGenerateTask: HFI_ImageGenerate_Stream,
+  ImageEditTask: HFI_ImageEdit_Stream
+};
+
+// src/ai-provider/HfInferenceQueuedProvider.ts
+import { AiProvider } from "@workglow/ai";
+class HfInferenceQueuedProvider extends AiProvider {
+  name = HF_INFERENCE;
+  displayName = "Hugging Face Inference";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "ToolCallingTask",
+    "ModelSearchTask",
+    "ImageGenerateTask",
+    "ImageEditTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/common/HFI_ImageValidation.ts
+import { AiImageOutputTask, ProviderUnsupportedFeatureError } from "@workglow/ai";
+function registerHfImageValidator() {
+  AiImageOutputTask.registerProviderImageValidator(HF_INFERENCE, (taskType, input, model) => {
+    if (taskType !== "ImageEditTask")
+      return;
+    const modelId = model.model_id ?? "";
+    const modelName = model.provider_config?.model_name ?? modelId;
+    const additional = input["additionalImages"];
+    if (Array.isArray(additional) && additional.length > 0) {
+      throw new ProviderUnsupportedFeatureError("additionalImages", modelId, "HF Inference image-to-image only supports a single input image");
+    }
+    if (input["mask"] !== undefined && input["mask"] !== null && !isHfInpaintingModel(modelName)) {
+      throw new ProviderUnsupportedFeatureError("mask", modelId, "Mask is only supported on HF inpainting models (e.g., FLUX.1-Kontext-dev)");
+    }
+  });
+}
+
+// src/ai-provider/registerHfInferenceInline.ts
+async function registerHfInferenceInline(options) {
+  registerHfImageValidator();
+  await registerProviderInline(new HfInferenceQueuedProvider(HFI_TASKS, HFI_STREAM_TASKS), "Hugging Face Inference", options);
+}
+
+// src/ai-provider/registerHfInferenceWorker.ts
+import { registerProviderWorker } from "@workglow/ai-provider/common";
+
+// src/ai-provider/HfInferenceProvider.ts
+import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
+class HfInferenceProvider extends AiProvider2 {
+  name = HF_INFERENCE;
+  displayName = "Hugging Face Inference";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/registerHfInferenceWorker.ts
+async function registerHfInferenceWorker() {
+  await registerProviderWorker((ws) => new HfInferenceProvider(HFI_TASKS, HFI_STREAM_TASKS).registerOnWorkerServer(ws), "Hugging Face Inference");
+}
+export {
+  registerHfInferenceWorker,
+  registerHfInferenceInline,
+  loadHfInferenceSDK,
+  getProvider,
+  getModelName,
+  getClient
+};
+
+//# debugId=73A7815234272E4A64756E2164756E21