@workglow/huggingface-inference 0.3.17 → 0.3.18

package/dist/ai/registerHfInferenceInline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRegisterOptions } from "@workglow/ai";
+export declare function registerHfInferenceInline(options?: AiProviderRegisterOptions): Promise<void>;
+//# sourceMappingURL=registerHfInferenceInline.d.ts.map

package/dist/ai/registerHfInferenceInline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerHfInferenceInline.d.ts","sourceRoot":"","sources":["../../src/ai/registerHfInferenceInline.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAM9D,wBAAsB,yBAAyB,CAC7C,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,IAAI,CAAC,CAOf"}

package/dist/ai/registerHfInferenceWorker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function registerHfInferenceWorker(): Promise<void>;
+//# sourceMappingURL=registerHfInferenceWorker.d.ts.map

package/dist/ai/registerHfInferenceWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerHfInferenceWorker.d.ts","sourceRoot":"","sources":["../../src/ai/registerHfInferenceWorker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAK/D"}

package/dist/ai/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Worker server and main-thread inline Hugging Face Inference registration (pulls in `HFI_JobRunFns`),
+ * plus API client helpers (`HFI_Client`).
+ * Import from `@workglow/huggingface-inference/ai-runtime` — not from the main `hf-inference` barrel.
+ *
+ * Use `export *` (not `export { … } from "…"`) so the Bun bundler keeps the module graph.
+ */
+export * from "./common/HFI_Client";
+export * from "./registerHfInferenceInline";
+export * from "./registerHfInferenceWorker";
+//# sourceMappingURL=runtime.d.ts.map

package/dist/ai/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/ai/runtime.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AAGH,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC"}

package/dist/ai-runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./ai/runtime";
+//# sourceMappingURL=ai-runtime.d.ts.map

package/dist/ai-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-runtime.d.ts","sourceRoot":"","sources":["../src/ai-runtime.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,cAAc,cAAc,CAAC"}

package/dist/ai-runtime.js

@@ -0,0 +1,544 @@
+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/common/HFI_Client.ts
+import { resolveApiKey } from "@workglow/ai/provider-utils";
+var _loadPromise;
+async function loadHfInferenceSDK() {
+  _loadPromise ??= import("@huggingface/inference").then((mod) => mod).catch(() => {
+    _loadPromise = undefined;
+    throw new Error("@huggingface/inference is required for Hugging Face Inference tasks. Install it with: bun add @huggingface/inference");
+  });
+  return _loadPromise;
+}
+async function getClient(model) {
+  const sdk = await loadHfInferenceSDK();
+  const config = model?.provider_config;
+  const apiKey = resolveApiKey({
+    config,
+    envVar: "HF_TOKEN",
+    providerLabel: "Hugging Face"
+  });
+  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/registerHfInferenceInline.ts
+import { registerProviderInline } from "@workglow/ai/provider-utils";
+
+// src/ai/common/HFI_ImageValidation.ts
+import { AiImageOutputTask, ProviderUnsupportedFeatureError } from "@workglow/ai";
+
+// src/ai/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/common/HFI_Constants.ts
+var HF_INFERENCE = "HF_INFERENCE";
+
+// src/ai/common/HFI_ImageValidation.ts
+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/common/HFI_CapabilitySets.ts
+var HFI_TEXT_GENERATION = ["text.generation"];
+var HFI_TOOL_USE = ["text.generation", "tool-use"];
+var HFI_TEXT_REWRITER = ["text.rewriter"];
+var HFI_TEXT_SUMMARY = ["text.summary"];
+var HFI_TEXT_EMBEDDING = ["text.embedding"];
+var HFI_IMAGE_GENERATION = ["image.generation"];
+var HFI_IMAGE_EDITING = ["image.editing"];
+var HFI_MODEL_SEARCH = ["model.search"];
+var HFI_MODEL_INFO = ["model.info"];
+var HFI_CAPABILITY_SETS = [
+  HFI_TEXT_GENERATION,
+  HFI_TOOL_USE,
+  HFI_TEXT_REWRITER,
+  HFI_TEXT_SUMMARY,
+  HFI_TEXT_EMBEDDING,
+  HFI_IMAGE_GENERATION,
+  HFI_IMAGE_EDITING,
+  HFI_MODEL_SEARCH,
+  HFI_MODEL_INFO
+];
+
+// src/ai/common/HFI_ImageEdit.ts
+import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
+import { getLogger } from "@workglow/util/worker";
+import {
+  blobToImageValue,
+  imageValueToPngBytes,
+  modelIdForError
+} from "@workglow/ai/provider-utils";
+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_Stream = async (input, model, signal, emit) => {
+  const logger = getLogger();
+  const timer = `hfi:ImageEdit:${getModelName(model)}`;
+  logger.time(timer);
+  let result;
+  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);
+    logger.timeEnd(timer);
+    result = { 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(modelIdForError(model, "huggingface"), msg);
+    throw new ImageGenerationProviderError(modelIdForError(model, "huggingface"), msg, {
+      cause: err
+    });
+  }
+  if (signal.aborted)
+    return;
+  emit({ type: "finish", data: result });
+};
+
+// src/ai/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, modelIdForError as modelIdForError2 } from "@workglow/ai/provider-utils";
+var HFI_ImageGenerate_Stream = async (input, model, signal, emit) => {
+  const logger = getLogger2();
+  const timer = `hfi:ImageGenerate:${getModelName(model)}`;
+  logger.time(timer);
+  let result;
+  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);
+    logger.timeEnd(timer);
+    result = { 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(modelIdForError2(model, "huggingface"), msg);
+    throw new ImageGenerationProviderError2(modelIdForError2(model, "huggingface"), msg, {
+      cause: err
+    });
+  }
+  if (signal.aborted)
+    return;
+  emit({ type: "finish", data: result });
+};
+
+// src/ai/common/HFI_ModelInfo.ts
+var HFI_ModelInfo = async (input, model, _signal, emit) => {
+  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;
+    emit({
+      type: "finish",
+      data: {
+        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;
+  }
+  emit({
+    type: "finish",
+    data: {
+      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/common/HFI_ModelSearch.ts
+import {
+  filterLabeledModelsByQuery,
+  mapHfModelResult,
+  searchHfModels
+} from "@workglow/ai/provider-utils";
+var HFI_IMAGE_MODELS = [
+  { id: "black-forest-labs/FLUX.1-schnell", capabilities: ["image.generation"] },
+  { id: "black-forest-labs/FLUX.1-Kontext-dev", capabilities: ["image.editing"] }
+];
+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: "",
+      capabilities: m.capabilities,
+      provider_config: { model_name: m.id },
+      metadata: {}
+    },
+    raw: m
+  }));
+}
+var HFI_ModelSearch = async (input, _model, signal, emit) => {
+  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));
+    emit({ type: "finish", data: { results: filtered } });
+    return;
+  }
+  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.capabilities = imageEntry.capabilities;
+    }
+    return mapped;
+  });
+  emit({ type: "finish", data: { results } });
+};
+
+// src/ai/common/HFI_TextEmbedding.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+var HFI_TextEmbedding = async (input, model, signal, emit) => {
+  const logger = getLogger3();
+  const timerLabel = `hfi:TextEmbedding:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  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 })));
+    logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name, batch: true });
+    emit({
+      type: "finish",
+      data: {
+        vector: embeddings.map((embedding2) => new Float32Array(embedding2))
+      }
+    });
+    return;
+  }
+  const embedding = await client.featureExtraction({
+    model: modelName,
+    inputs: input.text
+  }, { signal });
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  emit({
+    type: "finish",
+    data: { vector: new Float32Array(embedding) }
+  });
+};
+
+// src/ai/common/HFI_TextGeneration.ts
+import { toOpenAIMessages } from "@workglow/ai/worker";
+var HFI_TextGeneration_Stream = async (input, model, signal, emit) => {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const unified = input;
+  const hasMessages = Array.isArray(unified.messages) && unified.messages.length > 0;
+  const messages = hasMessages ? toOpenAIMessages({
+    messages: unified.messages,
+    systemPrompt: unified.systemPrompt,
+    prompt: "",
+    tools: []
+  }).map((m) => ({ ...m, content: m.content ?? "" })) : [{ role: "user", content: input.prompt }];
+  const stream = client.chatCompletionStream({
+    model: modelName,
+    messages,
+    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) {
+      emit({ type: "text-delta", port: "text", textDelta: delta });
+    }
+  }
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/HFI_TextRewriter.ts
+var HFI_TextRewriter_Stream = async (input, model, signal, emit) => {
+  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) {
+      emit({ type: "text-delta", port: "text", textDelta: delta });
+    }
+  }
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/HFI_TextSummary.ts
+var HFI_TextSummary_Stream = async (input, model, signal, emit) => {
+  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) {
+      emit({ type: "text-delta", port: "text", textDelta: delta });
+    }
+  }
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/HFI_ToolCalling.ts
+import {
+  accumulateOpenAIStream,
+  buildOpenAITools,
+  mapOpenAIToolChoice
+} from "@workglow/ai/provider-utils";
+import { toOpenAIMessages as toOpenAIMessages2 } from "@workglow/ai/worker";
+var HFI_ToolCalling_Stream = async (input, model, signal, emit) => {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const tools = buildOpenAITools(input.tools);
+  const messages = toOpenAIMessages2(input);
+  const toolChoice = mapOpenAIToolChoice(input.toolChoice, false);
+  const params = {
+    model: modelName,
+    messages,
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    provider,
+    stream: true
+  };
+  if (toolChoice !== "none") {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  const stream = client.chatCompletionStream(params, { signal });
+  await accumulateOpenAIStream(stream, emit);
+  emit({ type: "finish", data: { text: "", toolCalls: [] } });
+};
+
+// src/ai/common/HFI_JobRunFns.ts
+var HFI_TextGeneration_Unified = HFI_TextGeneration_Stream;
+var HFI_RUN_FNS = [
+  { serves: HFI_TEXT_GENERATION, runFn: HFI_TextGeneration_Unified },
+  { serves: HFI_TOOL_USE, runFn: HFI_ToolCalling_Stream },
+  { serves: HFI_TEXT_REWRITER, runFn: HFI_TextRewriter_Stream },
+  { serves: HFI_TEXT_SUMMARY, runFn: HFI_TextSummary_Stream },
+  { serves: HFI_TEXT_EMBEDDING, runFn: HFI_TextEmbedding },
+  { serves: HFI_IMAGE_GENERATION, runFn: HFI_ImageGenerate_Stream },
+  { serves: HFI_IMAGE_EDITING, runFn: HFI_ImageEdit_Stream },
+  { serves: HFI_MODEL_SEARCH, runFn: HFI_ModelSearch },
+  { serves: HFI_MODEL_INFO, runFn: HFI_ModelInfo }
+];
+
+// src/ai/HfInferenceQueuedProvider.ts
+import { AiProvider } from "@workglow/ai";
+import { createCloudProviderClass } from "@workglow/ai/provider-utils";
+
+// src/ai/common/HFI_Capabilities.ts
+var HFI_RUN_FN_SPECS = HFI_CAPABILITY_SETS.map((serves) => ({ serves }));
+function hfInferenceWorkerRunFnSpecs() {
+  return HFI_RUN_FN_SPECS;
+}
+function inferHfInferenceCapabilities(model) {
+  const declared = model.capabilities ?? [];
+  if (declared.length > 0)
+    return declared;
+  const id = String(model.model_id ?? model.provider_config?.model_name ?? "");
+  const baseName = id.split("/").pop() ?? id;
+  if (/flux|stable-diffusion|sd-|sdxl|dall-e|kandinsky|wuerstchen|playground/i.test(baseName)) {
+    return ["image.generation", "image.editing", "model.info", "model.search"];
+  }
+  if (/embed|minilm|bge-|gte-|e5-/i.test(baseName)) {
+    return ["text.embedding", "model.info", "model.search"];
+  }
+  if (/llama|mistral|mixtral|gemma|phi|qwen|falcon|yi|deepseek|command|claude|gpt-/i.test(baseName)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "model.info",
+      "model.search"
+    ];
+  }
+  return ["model.search", "model.info"];
+}
+
+// src/ai/HfInferenceQueuedProvider.ts
+class HfInferenceQueuedProvider extends createCloudProviderClass(AiProvider, {
+  name: HF_INFERENCE,
+  displayName: "Hugging Face Inference"
+}) {
+  inferCapabilities(model) {
+    return inferHfInferenceCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return hfInferenceWorkerRunFnSpecs();
+  }
+}
+
+// src/ai/registerHfInferenceInline.ts
+async function registerHfInferenceInline(options) {
+  registerHfImageValidator();
+  await registerProviderInline(new HfInferenceQueuedProvider(HFI_RUN_FNS), "Hugging Face Inference", options);
+}
+
+// src/ai/registerHfInferenceWorker.ts
+import { registerProviderWorker } from "@workglow/ai/provider-utils";
+
+// src/ai/HfInferenceProvider.ts
+import { createCloudProviderClass as createCloudProviderClass2 } from "@workglow/ai/provider-utils";
+import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
+class HfInferenceProvider extends createCloudProviderClass2(AiProvider2, {
+  name: HF_INFERENCE,
+  displayName: "Hugging Face Inference"
+}) {
+  inferCapabilities(model) {
+    return inferHfInferenceCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return hfInferenceWorkerRunFnSpecs();
+  }
+}
+
+// src/ai/registerHfInferenceWorker.ts
+async function registerHfInferenceWorker() {
+  await registerProviderWorker((ws) => new HfInferenceProvider(HFI_RUN_FNS).registerOnWorkerServer(ws), "Hugging Face Inference");
+}
+export {
+  registerHfInferenceWorker,
+  registerHfInferenceInline,
+  loadHfInferenceSDK,
+  getProvider,
+  getModelName,
+  getClient
+};
+
+//# debugId=88BE26D07F1CA92964756E2164756E21