@workglow/huggingface-inference 0.2.34 → 0.2.36

package/dist/ai-runtime.js

@@ -44,54 +44,27 @@ function getProvider(model) {
 // src/ai/registerHfInferenceInline.ts
 import { registerProviderInline } from "@workglow/ai/provider-utils";
 
-// src/ai/common/HFI_ModelSearch.ts
-import { mapHfModelResult, searchHfModels } from "@workglow/ai/provider-utils";
-import { filterLabeledModelsByQuery } from "@workglow/ai/provider-utils";
-
-// src/ai/common/HFI_Constants.ts
-var HF_INFERENCE = "HF_INFERENCE";
-
-// src/ai/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"] }
+// 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
 ];
-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/common/HFI_ImageEdit.ts
 import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
@@ -135,11 +108,11 @@ async function gpuImageToBlob(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) => {
+var HFI_ImageEdit_Stream = async (input, model, signal, emit) => {
   const logger = getLogger();
   const timer = `hfi:ImageEdit:${getModelName(model)}`;
   logger.time(timer);
-  update_progress(0, "Starting HF image edit");
+  let result;
   try {
     const client = await getClient(model);
     const modelName = getModelName(model);
@@ -163,9 +136,8 @@ var HFI_ImageEdit = async (input, model, update_progress, signal) => {
       parameters: params
     }, { signal });
     const image = await blobToImageValue(blob);
-    update_progress(100, "Completed HF image edit");
     logger.timeEnd(timer);
-    return { image };
+    result = { image };
   } catch (err) {
     if (err instanceof ImageGenerationProviderError || err instanceof ImageGenerationContentPolicyError)
       throw err;
@@ -174,13 +146,9 @@ var HFI_ImageEdit = async (input, model, update_progress, signal) => {
       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: {} };
+  emit({ type: "finish", data: result });
 };
 
 // src/ai/common/HFI_ImageGenerate.ts
@@ -190,11 +158,11 @@ import { blobToImageValue as blobToImageValue2 } from "@workglow/ai/provider-uti
 function modelIdOf2(model) {
   return model?.model_id ?? model?.provider_config?.model_name ?? "huggingface";
 }
-var HFI_ImageGenerate = async (input, model, update_progress, signal) => {
+var HFI_ImageGenerate_Stream = async (input, model, signal, emit) => {
   const logger = getLogger2();
   const timer = `hfi:ImageGenerate:${getModelName(model)}`;
   logger.time(timer);
-  update_progress(0, "Starting HF image generation");
+  let result;
   try {
     const client = await getClient(model);
     const modelName = getModelName(model);
@@ -211,9 +179,8 @@ var HFI_ImageGenerate = async (input, model, update_progress, signal) => {
       }
     }, { outputType: "blob", signal });
     const image = await blobToImageValue2(blob);
-    update_progress(100, "Completed HF image generation");
     logger.timeEnd(timer);
-    return { image };
+    result = { image };
   } catch (err) {
     if (err instanceof ImageGenerationProviderError2 || err instanceof ImageGenerationContentPolicyError2)
       throw err;
@@ -222,22 +189,37 @@ var HFI_ImageGenerate = async (input, model, update_progress, signal) => {
       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: {} };
+  emit({ type: "finish", data: result });
 };
 
 // src/ai/common/HFI_ModelInfo.ts
-var HFI_ModelInfo = async (input, model) => {
+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;
-    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,
+        ...native_dimensions !== undefined ? { native_dimensions } : {},
+        ...mrl ? { mrl } : {}
+      }
+    });
+    return;
+  }
+  emit({
+    type: "finish",
+    data: {
       model: input.model,
       is_local: false,
       is_remote: true,
@@ -245,30 +227,67 @@ var HFI_ModelInfo = async (input, model) => {
       supports_node: true,
       is_cached: false,
       is_loaded: false,
-      file_sizes: null,
-      ...native_dimensions !== undefined ? { native_dimensions } : {},
-      ...mrl ? { mrl } : {}
-    };
+      file_sizes: null
+    }
+  });
+};
+
+// src/ai/common/HFI_ModelSearch.ts
+import { mapHfModelResult, searchHfModels } from "@workglow/ai/provider-utils";
+import { filterLabeledModelsByQuery } from "@workglow/ai/provider-utils";
+
+// src/ai/common/HFI_Constants.ts
+var HF_INFERENCE = "HF_INFERENCE";
+
+// src/ai/common/HFI_ModelSearch.ts
+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;
   }
-  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
-  };
+  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, update_progress, signal) => {
+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 });
-  update_progress(0, "Starting HF Inference text embedding");
   const client = await getClient(model);
   const modelName = getModelName(model);
   if (Array.isArray(input.text)) {
@@ -276,45 +295,28 @@ var HFI_TextEmbedding = async (input, model, update_progress, signal) => {
       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))
-    };
+    emit({
+      type: "finish",
+      data: {
+        vector: embeddings.map((embedding2) => new Float32Array(embedding2))
+      }
+    });
+    return;
   }
   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) };
+  emit({
+    type: "finish",
+    data: { vector: new Float32Array(embedding) }
+  });
 };
 
 // src/ai/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) {
+var HFI_TextGeneration_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const provider = getProvider(model);
@@ -330,30 +332,14 @@ var HFI_TextGeneration_Stream = async function* (input, model, signal) {
   for await (const chunk of stream) {
     const delta = chunk.choices[0]?.delta?.content ?? "";
     if (delta) {
-      yield { type: "text-delta", port: "text", textDelta: delta };
+      emit({ type: "text-delta", port: "text", textDelta: delta });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/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) {
+var HFI_TextRewriter_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const provider = getProvider(model);
@@ -368,30 +354,14 @@ var HFI_TextRewriter_Stream = async function* (input, model, signal) {
   for await (const chunk of stream) {
     const delta = chunk.choices[0]?.delta?.content ?? "";
     if (delta) {
-      yield { type: "text-delta", port: "text", textDelta: delta };
+      emit({ type: "text-delta", port: "text", textDelta: delta });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/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) {
+var HFI_TextSummary_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const provider = getProvider(model);
@@ -406,46 +376,20 @@ var HFI_TextSummary_Stream = async function* (input, model, signal) {
   for await (const chunk of stream) {
     const delta = chunk.choices[0]?.delta?.content ?? "";
     if (delta) {
-      yield { type: "text-delta", port: "text", textDelta: delta };
+      emit({ type: "text-delta", port: "text", textDelta: delta });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/HFI_ToolCalling.ts
-import { filterValidToolCalls, toOpenAIMessages } from "@workglow/ai/worker";
+import { toOpenAIMessages } from "@workglow/ai/worker";
 import {
   accumulateOpenAIStream,
   buildOpenAITools,
-  mapOpenAIToolChoice,
-  parseOpenAIToolCallMessage
+  mapOpenAIToolChoice
 } from "@workglow/ai/provider-utils";
-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 = buildOpenAITools(input.tools);
-  const messages = toOpenAIMessages(input);
-  const toolChoice = mapOpenAIToolChoice(input.toolChoice, false);
-  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 = parseOpenAIToolCallMessage(response.choices[0]?.message?.tool_calls);
-  update_progress(100, "Completed HF Inference tool calling");
-  return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
-};
-var HFI_ToolCalling_Stream = async function* (input, model, signal) {
+var HFI_ToolCalling_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const provider = getProvider(model);
@@ -465,50 +409,70 @@ var HFI_ToolCalling_Stream = async function* (input, model, signal) {
     params.tool_choice = toolChoice;
   }
   const stream = client.chatCompletionStream(params, { signal });
-  yield* accumulateOpenAIStream(stream);
+  for await (const e of accumulateOpenAIStream(stream)) {
+    emit(e);
+  }
 };
 
 // src/ai/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
-};
+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";
-var HFI_QUEUED_TASK_TYPES = [
-  "ModelInfoTask",
-  "TextGenerationTask",
-  "TextEmbeddingTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "ToolCallingTask",
-  "ModelSearchTask",
-  "ImageGenerateTask",
-  "ImageEditTask"
-];
 
+// 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",
-  taskTypes: HFI_QUEUED_TASK_TYPES
+  displayName: "Hugging Face Inference"
 }) {
+  inferCapabilities(model) {
+    return inferHfInferenceCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return hfInferenceWorkerRunFnSpecs();
+  }
 }
 
 // src/ai/common/HFI_ImageValidation.ts
@@ -532,7 +496,7 @@ function registerHfImageValidator() {
 // src/ai/registerHfInferenceInline.ts
 async function registerHfInferenceInline(options) {
   registerHfImageValidator();
-  await registerProviderInline(new HfInferenceQueuedProvider(HFI_TASKS, HFI_STREAM_TASKS), "Hugging Face Inference", options);
+  await registerProviderInline(new HfInferenceQueuedProvider(HFI_RUN_FNS), "Hugging Face Inference", options);
 }
 
 // src/ai/registerHfInferenceWorker.ts
@@ -541,26 +505,21 @@ import { registerProviderWorker } from "@workglow/ai/provider-utils";
 // src/ai/HfInferenceProvider.ts
 import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
 import { createCloudProviderClass as createCloudProviderClass2 } from "@workglow/ai/provider-utils";
-var HFI_WORKER_TASK_TYPES = [
-  "ModelInfoTask",
-  "TextGenerationTask",
-  "TextEmbeddingTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "ToolCallingTask",
-  "ModelSearchTask"
-];
-
 class HfInferenceProvider extends createCloudProviderClass2(AiProvider2, {
   name: HF_INFERENCE,
-  displayName: "Hugging Face Inference",
-  taskTypes: HFI_WORKER_TASK_TYPES
+  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_TASKS, HFI_STREAM_TASKS).registerOnWorkerServer(ws), "Hugging Face Inference");
+  await registerProviderWorker((ws) => new HfInferenceProvider(HFI_RUN_FNS).registerOnWorkerServer(ws), "Hugging Face Inference");
 }
 export {
   registerHfInferenceWorker,
@@ -571,4 +530,4 @@ export {
   getClient
 };
 
-//# debugId=5D7101999CE2E9A764756E2164756E21
+//# debugId=1CA6F5315201146E64756E2164756E21