@workglow/huggingface-transformers 0.2.34 → 0.2.35

package/dist/ai-runtime.js

@@ -197,14 +197,29 @@ function disposeHftSessionsForModel(modelPath) {
     }
   }
 }
-function clearPipelineCache() {
+async function clearPipelineCache() {
+  const snapshot = Array.from(pipelines.values());
   pipelines.clear();
+  await Promise.allSettled(snapshot.map(async (pipeline) => {
+    try {
+      const model = pipeline?.model;
+      await model?.dispose?.();
+    } catch {}
+  }));
 }
 function hasCachedPipeline(cacheKey) {
   return pipelines.has(cacheKey);
 }
-function removeCachedPipeline(cacheKey) {
-  return pipelines.delete(cacheKey);
+async function removeCachedPipeline(cacheKey) {
+  const pipeline = pipelines.get(cacheKey);
+  const deleted = pipelines.delete(cacheKey);
+  if (pipeline) {
+    try {
+      const model = pipeline?.model;
+      await model?.dispose?.();
+    } catch {}
+  }
+  return deleted;
 }
 function isBrowserEnv() {
   if (typeof globalThis === "undefined")
@@ -221,7 +236,10 @@ function getPipelineCacheKey(model) {
   const revision = model.provider_config.revision || "main";
   return `${model.provider_config.model_path}:${model.provider_config.pipeline}:${dtype}:${device}:${revision}`;
 }
-async function getPipeline(model, onProgress, options = {}, signal, progressScaleMax = 10) {
+async function getPipeline(model, emit, options = {}, signal, progressScaleMax = 10) {
+  if (signal?.aborted) {
+    throw signal?.reason ?? new Error("Aborted");
+  }
   const cacheKey = getPipelineCacheKey(model);
   if (pipelines.has(cacheKey)) {
     getLogger().debug("HFT pipeline cache hit", { cacheKey });
@@ -236,28 +254,18 @@ async function getPipeline(model, onProgress, options = {}, signal, progressScal
     if (cached)
       return cached;
   }
-  const loadPromise = doGetPipeline(model, onProgress, options, progressScaleMax, cacheKey, signal).finally(() => {
+  const loadPromise = doGetPipeline(model, emit, options, progressScaleMax, cacheKey, signal).finally(() => {
     pipelineLoadPromises.delete(cacheKey);
   });
   pipelineLoadPromises.set(cacheKey, loadPromise);
   return loadPromise;
 }
-var _transformersSdk, _cacheDir, _loadPromise, modelAbortControllers, pipelines, hftSessions, pipelineLoadPromises, IMAGE_PIPELINE_TYPES, HFT_NULL_PROCESSOR_PREFIX = "HFT_NULL_PROCESSOR:", doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKey, signal) => {
+var _transformersSdk, _cacheDir, _loadPromise, modelAbortControllers, pipelines, hftSessions, pipelineLoadPromises, IMAGE_PIPELINE_TYPES, HFT_NULL_PROCESSOR_PREFIX = "HFT_NULL_PROCESSOR:", doGetPipeline = async (model, emit, options, progressScaleMax, cacheKey, signal) => {
   let lastProgressTime = 0;
   let pendingProgress = null;
   let throttleTimer = null;
   const THROTTLE_MS = 160;
-  const buildProgressDetails = (file, fileProgress, filesMap) => {
-    const details = {
-      file,
-      progress: fileProgress
-    };
-    if (filesMap && Object.keys(filesMap).length > 0) {
-      details.files = filesMap;
-    }
-    return details;
-  };
-  const sendProgress = (progress, file, fileProgress, filesMap) => {
+  const sendProgress = (progress) => {
     const now = Date.now();
     const timeSinceLastEvent = now - lastProgressTime;
     const isFirst = lastProgressTime === 0;
@@ -268,19 +276,22 @@ var _transformersSdk, _cacheDir, _loadPromise, modelAbortControllers, pipelines,
         throttleTimer = null;
       }
       pendingProgress = null;
-      onProgress(Math.round(progress), "Downloading model", buildProgressDetails(file, fileProgress, filesMap));
+      emit({ type: "phase", message: "Downloading model", progress: Math.round(progress) });
       lastProgressTime = now;
       return;
     }
     if (timeSinceLastEvent < THROTTLE_MS) {
-      pendingProgress = { progress, file, fileProgress, filesMap };
+      pendingProgress = progress;
       if (!throttleTimer) {
         const timeRemaining = Math.max(1, THROTTLE_MS - timeSinceLastEvent);
         throttleTimer = setTimeout(() => {
           throttleTimer = null;
-          if (pendingProgress) {
-            const p = pendingProgress;
-            onProgress(Math.round(p.progress), "Downloading model", buildProgressDetails(p.file, p.fileProgress, p.filesMap));
+          if (pendingProgress !== null) {
+            emit({
+              type: "phase",
+              message: "Downloading model",
+              progress: Math.round(pendingProgress)
+            });
             lastProgressTime = Date.now();
             pendingProgress = null;
           }
@@ -288,7 +299,7 @@ var _transformersSdk, _cacheDir, _loadPromise, modelAbortControllers, pipelines,
       }
       return;
     }
-    onProgress(Math.round(progress), "Downloading model", buildProgressDetails(file, fileProgress, filesMap));
+    emit({ type: "phase", message: "Downloading model", progress: Math.round(progress) });
     lastProgressTime = now;
     pendingProgress = null;
   };
@@ -307,28 +318,8 @@ var _transformersSdk, _cacheDir, _loadPromise, modelAbortControllers, pipelines,
     if (abortSignal?.aborted)
       return;
     if (status.status === "progress_total") {
-      const totalStatus = status;
-      const scaledProgress = totalStatus.progress * progressScaleMax / 100;
-      let activeFile = "";
-      let activeFileProgress = 0;
-      const files = totalStatus.files;
-      if (files) {
-        for (const [file, info] of Object.entries(files)) {
-          if (info.loaded < info.total) {
-            activeFile = file;
-            activeFileProgress = info.total > 0 ? info.loaded / info.total * 100 : 0;
-            break;
-          }
-        }
-        if (!activeFile) {
-          const fileNames = Object.keys(files);
-          if (fileNames.length > 0) {
-            activeFile = fileNames[fileNames.length - 1];
-            activeFileProgress = 100;
-          }
-        }
-      }
-      sendProgress(scaledProgress, activeFile, activeFileProgress, files);
+      const scaledProgress = status.progress * progressScaleMax / 100;
+      sendProgress(scaledProgress);
     }
   };
   let device = model.provider_config.device;
@@ -371,9 +362,12 @@ var _transformersSdk, _cacheDir, _loadPromise, modelAbortControllers, pipelines,
       clearTimeout(throttleTimer);
       throttleTimer = null;
     }
-    const finalPending = pendingProgress;
-    if (finalPending) {
-      onProgress(Math.round(finalPending.progress), "Downloading model", buildProgressDetails(finalPending.file, finalPending.fileProgress, finalPending.filesMap));
+    if (pendingProgress !== null) {
+      emit({
+        type: "phase",
+        message: "Downloading model",
+        progress: Math.round(pendingProgress)
+      });
       pendingProgress = null;
     }
     if (abortSignal?.aborted) {
@@ -734,31 +728,66 @@ import { registerProviderInline } from "@workglow/ai/provider-utils";
 // src/ai/common/HFT_InlineLifecycle.ts
 async function clearHftInlinePipelineCache() {
   const { clearPipelineCache: clearPipelineCache2 } = await Promise.resolve().then(() => (init_HFT_Pipeline(), exports_HFT_Pipeline));
-  clearPipelineCache2();
+  await clearPipelineCache2();
 }
 
-// src/ai/common/HFT_ModelSearch.ts
-import { searchHfModels, mapHfModelResult } from "@workglow/ai/provider-utils";
-var HFT_ModelSearch = async (input, _model, _onProgress, signal) => {
-  const entries = await searchHfModels(input.query?.trim() ?? "", { filter: "onnx" }, ["siblings"], signal);
-  const results = entries.map((entry) => {
-    const item = mapHfModelResult(entry, HF_TRANSFORMERS_ONNX);
-    if (entry.siblings && entry.siblings.length > 0) {
-      const filePaths = entry.siblings.map((s) => s.rfilename);
-      const quantizations = parseOnnxQuantizations({ filePaths });
-      if (quantizations.length > 0) {
-        const record = item.record;
-        const providerConfig = record.provider_config ?? {};
-        providerConfig.quantizations = quantizations;
-        record.provider_config = providerConfig;
-      }
-    }
-    const raw = item.raw;
-    delete raw.siblings;
-    return item;
-  });
-  return { results };
-};
+// src/ai/common/HFT_CapabilitySets.ts
+var HFT_TEXT_GENERATION = ["text.generation"];
+var HFT_TOOL_USE = ["text.generation", "tool-use"];
+var HFT_JSON_MODE = ["text.generation", "json-mode"];
+var HFT_TEXT_REWRITER = ["text.rewriter"];
+var HFT_TEXT_SUMMARY = ["text.summary"];
+var HFT_TEXT_TRANSLATION = ["text.translation"];
+var HFT_TEXT_QUESTION_ANSWERING = [
+  "text.question-answering"
+];
+var HFT_TEXT_EMBEDDING = ["text.embedding"];
+var HFT_TEXT_CLASSIFICATION = ["text.classification"];
+var HFT_TEXT_LANGUAGE_DETECTION = [
+  "text.language-detection"
+];
+var HFT_TEXT_FILL_MASK = ["text.fill-mask"];
+var HFT_TEXT_NER = ["text.ner"];
+var HFT_IMAGE_CLASSIFICATION = ["image.classification"];
+var HFT_IMAGE_EMBEDDING = ["image.embedding"];
+var HFT_IMAGE_SEGMENTATION = ["image.segmentation"];
+var HFT_IMAGE_TO_TEXT = ["image.to-text"];
+var HFT_IMAGE_BACKGROUND_REMOVAL = [
+  "image.background-removal"
+];
+var HFT_IMAGE_OBJECT_DETECTION = [
+  "image.object-detection"
+];
+var HFT_COUNT_TOKENS = ["model.count-tokens"];
+var HFT_MODEL_DOWNLOAD_REMOVE = ["model.download-remove"];
+var HFT_MODEL_DOWNLOAD = ["model.download"];
+var HFT_MODEL_SEARCH = ["model.search"];
+var HFT_MODEL_INFO = ["model.info"];
+var HFT_CAPABILITY_SETS = [
+  HFT_TEXT_GENERATION,
+  HFT_TOOL_USE,
+  HFT_JSON_MODE,
+  HFT_TEXT_REWRITER,
+  HFT_TEXT_SUMMARY,
+  HFT_TEXT_TRANSLATION,
+  HFT_TEXT_QUESTION_ANSWERING,
+  HFT_TEXT_EMBEDDING,
+  HFT_TEXT_CLASSIFICATION,
+  HFT_TEXT_LANGUAGE_DETECTION,
+  HFT_TEXT_FILL_MASK,
+  HFT_TEXT_NER,
+  HFT_IMAGE_CLASSIFICATION,
+  HFT_IMAGE_EMBEDDING,
+  HFT_IMAGE_SEGMENTATION,
+  HFT_IMAGE_TO_TEXT,
+  HFT_IMAGE_BACKGROUND_REMOVAL,
+  HFT_IMAGE_OBJECT_DETECTION,
+  HFT_COUNT_TOKENS,
+  HFT_MODEL_DOWNLOAD_REMOVE,
+  HFT_MODEL_DOWNLOAD,
+  HFT_MODEL_SEARCH,
+  HFT_MODEL_INFO
+];
 
 // src/ai/common/HFT_BackgroundRemoval.ts
 init_HFT_Pipeline();
@@ -770,15 +799,18 @@ function rawImageToBase64Png(image) {
   }
   return fn.call(image);
 }
-var HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
-  const remover = await getPipeline(model, onProgress, {}, signal);
+var HFT_BackgroundRemoval = async (input, model, signal, emit) => {
+  const remover = await getPipeline(model, emit, {}, signal);
   const imageArg = await imageValueToBlob(input.image);
   const result = await remover(imageArg);
   const resultImage = Array.isArray(result) ? result[0] : result;
   const dataUri = `data:image/png;base64,${rawImageToBase64Png(resultImage)}`;
-  return {
-    image: await dataUriToImageValue(dataUri)
-  };
+  emit({
+    type: "finish",
+    data: {
+      image: await dataUriToImageValue(dataUri)
+    }
+  });
 };
 
 // src/ai/common/HFT_Chat.ts
@@ -800,64 +832,11 @@ import {
 } from "@workglow/ai/provider-utils";
 
 // src/ai/common/HFT_Streaming.ts
-function createStreamEventQueue() {
-  const buffer = [];
-  let resolve = null;
-  let finished = false;
-  let err = null;
-  const push = (event) => {
-    if (resolve) {
-      const r = resolve;
-      resolve = null;
-      r({ value: event, done: false });
-    } else {
-      buffer.push(event);
-    }
-  };
-  const done = () => {
-    finished = true;
-    if (resolve) {
-      const r = resolve;
-      resolve = null;
-      r({ value: undefined, done: true });
-    }
-  };
-  const error = (e) => {
-    err = e;
-    if (resolve) {
-      const r = resolve;
-      resolve = null;
-      r({ value: undefined, done: true });
-    }
-  };
-  const iterable = {
-    [Symbol.asyncIterator]() {
-      return {
-        next() {
-          if (err)
-            return Promise.reject(err);
-          if (buffer.length > 0) {
-            return Promise.resolve({ value: buffer.shift(), done: false });
-          }
-          if (finished) {
-            return Promise.resolve({ value: undefined, done: true });
-          }
-          return new Promise((r) => {
-            resolve = r;
-          });
-        }
-      };
-    }
-  };
-  return { push, done, error, iterable };
-}
-function createStreamingTextStreamer(tokenizer, queue, textStreamer) {
+function createStreamingTextStreamer(tokenizer, onText, textStreamer) {
   return new textStreamer(tokenizer, {
     skip_prompt: true,
     decode_kwargs: { skip_special_tokens: true },
-    callback_function: (text) => {
-      queue.push({ type: "text-delta", port: "text", textDelta: text });
-    }
+    callback_function: onText
   });
 }
 function createTextStreamer(tokenizer, updateProgress, textStreamer) {
@@ -1025,76 +1004,19 @@ function buildPromptAndPrefix(tokenizer, input, modelFamily) {
     responsePrefix
   };
 }
-var HFT_ToolCalling = async (input, model, onProgress, signal, _outputSchema, sessionId) => {
-  const generateText = await getPipeline(model, onProgress, {}, signal);
-  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const hfTokenizer = generateText.tokenizer;
-  const hfModel = generateText.model;
-  const streamer = createTextStreamer(hfTokenizer, onProgress, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
-  const modelFamily = detectModelFamilyFromConfig(model);
-  const { prompt, responsePrefix } = buildPromptAndPrefix(hfTokenizer, input, modelFamily);
-  const inputs = hfTokenizer(prompt, { return_tensor: true });
-  const modelPath = model.provider_config.model_path;
-  let session = sessionId ? getHftSession(sessionId) : undefined;
-  let past_key_values = undefined;
-  if (sessionId && !session) {
-    const { DynamicCache } = await loadTransformersSDK();
-    const cache = new DynamicCache;
-    await hfModel.generate({
-      ...inputs,
-      max_new_tokens: 0,
-      past_key_values: cache
-    });
-    const baseEntries = {};
-    for (const key of Object.keys(cache)) {
-      baseEntries[key] = cache[key];
-    }
-    const newSession = {
-      mode: "prefix-rewind",
-      baseEntries,
-      baseSeqLength: cache.get_seq_length(),
-      modelPath
-    };
-    setHftSession(sessionId, newSession);
-    session = newSession;
-  }
-  if (session?.mode === "prefix-rewind") {
-    const { DynamicCache } = await loadTransformersSDK();
-    past_key_values = new DynamicCache(session.baseEntries);
-  }
-  const output = await hfModel.generate({
-    ...inputs,
-    max_new_tokens: input.maxTokens ?? 1024,
-    streamer,
-    stopping_criteria: [stopping_criteria],
-    ...past_key_values ? { past_key_values } : {}
-  });
-  const promptLen = inputs.input_ids.dims[1];
-  const seqLen = output.dims[1];
-  const newTokens = output.slice(0, [promptLen, seqLen], null);
-  const decoded = hfTokenizer.decode(newTokens, {
-    skip_special_tokens: false
-  });
-  const parseableText = responsePrefix ? `${responsePrefix}${decoded}` : decoded;
-  const { text, toolCalls } = adaptParserResult(parseToolCalls(parseableText, { parser: modelFamily }));
-  return {
-    text,
-    toolCalls: filterValidToolCalls(normalizeParsedToolCalls(input, toolCalls), input.tools)
-  };
-};
-var HFT_ToolCalling_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
-  const noopProgress = () => {};
-  const generateText = await getPipeline(model, noopProgress, {}, signal);
+var HFT_ToolCalling = async (input, model, signal, emit, _outputSchema, sessionId) => {
+  const generateText = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
   const modelFamily = detectModelFamilyFromConfig(model);
   const { prompt, responsePrefix } = buildPromptAndPrefix(generateText.tokenizer, input, modelFamily);
-  const innerQueue = createStreamEventQueue();
-  const outerQueue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, innerQueue, TextStreamer);
+  let fullText = "";
+  const filter = createToolCallMarkupFilter((text) => {
+    emit({ type: "text-delta", port: "text", textDelta: text });
+  });
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, (text) => {
+    fullText += text;
+    filter.feed(text);
+  }, TextStreamer);
   const stopping_criteria = new InterruptableStoppingCriteria;
   if (signal) {
     signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
@@ -1130,57 +1052,33 @@ var HFT_ToolCalling_Stream = async function* (input, model, signal, _outputSchem
     const { DynamicCache } = await loadTransformersSDK();
     past_key_values = new DynamicCache(session.baseEntries);
   }
-  let fullText = "";
-  const filter = createToolCallMarkupFilter((text) => {
-    outerQueue.push({ type: "text-delta", port: "text", textDelta: text });
-  });
-  const originalPush = innerQueue.push;
-  innerQueue.push = (event) => {
-    if (event.type === "text-delta" && "textDelta" in event) {
-      fullText += event.textDelta;
-      filter.feed(event.textDelta);
-    } else {
-      outerQueue.push(event);
-    }
-    originalPush(event);
-  };
-  const originalDone = innerQueue.done;
-  innerQueue.done = () => {
-    filter.flush();
-    outerQueue.done();
-    originalDone();
-  };
-  const originalError = innerQueue.error;
-  innerQueue.error = (e) => {
+  try {
+    await generateText(prompt, {
+      max_new_tokens: input.maxTokens ?? 1024,
+      temperature: input.temperature ?? undefined,
+      return_full_text: false,
+      streamer,
+      stopping_criteria: [stopping_criteria],
+      ...past_key_values ? { past_key_values } : {}
+    });
+  } finally {
     filter.flush();
-    outerQueue.error(e);
-    originalError(e);
-  };
-  const pipelinePromise = generateText(prompt, {
-    max_new_tokens: input.maxTokens ?? 1024,
-    temperature: input.temperature ?? undefined,
-    return_full_text: false,
-    streamer,
-    stopping_criteria: [stopping_criteria],
-    ...past_key_values ? { past_key_values } : {}
-  }).then(() => innerQueue.done(), (err) => innerQueue.error(err));
-  yield* outerQueue.iterable;
-  await pipelinePromise;
+  }
   const parseableFullText = responsePrefix ? `${responsePrefix}${fullText}` : fullText;
   const { text: cleanedText, toolCalls } = adaptParserResult(parseToolCalls(parseableFullText, { parser: modelFamily }));
   const validToolCalls = filterValidToolCalls(normalizeParsedToolCalls(input, toolCalls), input.tools);
   if (validToolCalls.length > 0) {
-    yield { type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] };
+    emit({ type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] });
   }
-  yield {
+  emit({
     type: "finish",
     data: { text: cleanedText, toolCalls: validToolCalls }
-  };
+  });
 };
 
 // src/ai/common/HFT_Chat.ts
-async function generateTurn(input, model, sessionId, onProgress, signal, onDelta) {
-  const generateText = await getPipeline(model, onProgress, {}, signal);
+async function generateTurn(input, model, sessionId, emit, signal, onDelta) {
+  const generateText = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
   const hfTokenizer = generateText.tokenizer;
   const hfModel = generateText.model;
@@ -1205,16 +1103,12 @@ async function generateTurn(input, model, sessionId, onProgress, signal, onDelta
   let accumulated = "";
   let streamer;
   if (onDelta) {
-    const queue = createStreamEventQueue();
-    streamer = createStreamingTextStreamer(hfTokenizer, queue, TextStreamer);
-    queue.push = (event) => {
-      if (event.type === "text-delta" && "textDelta" in event) {
-        accumulated += event.textDelta;
-        onDelta(event.textDelta);
-      }
-    };
+    streamer = createStreamingTextStreamer(hfTokenizer, (text) => {
+      accumulated += text;
+      onDelta(text);
+    }, TextStreamer);
   } else {
-    streamer = createTextStreamer(hfTokenizer, onProgress, TextStreamer);
+    streamer = createTextStreamer(hfTokenizer, (progress, message) => emit({ type: "phase", message: message ?? "", progress }), TextStreamer);
   }
   const output = await hfModel.generate({
     ...inputs,
@@ -1252,112 +1146,140 @@ async function generateTurn(input, model, sessionId, onProgress, signal, onDelta
   }
   return accumulated;
 }
-var HFT_Chat = async (input, model, update_progress, signal, _outputSchema, sessionId) => {
-  update_progress(0, "HFT chat turn");
-  const text = await generateTurn(input, model, sessionId, update_progress, signal, undefined);
-  update_progress(100, "Turn complete");
-  return { text };
-};
-var HFT_Chat_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
-  const noopProgress = () => {};
-  const queue = [];
-  let done = false;
-  let resolver;
-  const task = (async () => {
-    try {
-      await generateTurn(input, model, sessionId, noopProgress, signal, (piece) => {
-        queue.push(piece);
-        resolver?.();
-      });
-    } finally {
-      done = true;
-      resolver?.();
-    }
-  })();
-  while (!done || queue.length > 0) {
-    if (queue.length === 0 && !done) {
-      await new Promise((res) => resolver = res);
-      resolver = undefined;
-    }
-    while (queue.length > 0) {
-      yield { type: "text-delta", port: "text", textDelta: queue.shift() };
-    }
-  }
-  await task;
-  yield { type: "finish", data: {} };
+var HFT_Chat = async (input, model, signal, emit, _outputSchema, sessionId) => {
+  await generateTurn(input, model, sessionId, emit, signal, (piece) => {
+    emit({ type: "text-delta", port: "text", textDelta: piece });
+  });
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/HFT_CountTokens.ts
 init_HFT_Pipeline();
-var HFT_CountTokens = async (input, model, onProgress, _signal) => {
+async function countTokens(input, model) {
   const { AutoTokenizer } = await loadTransformersSDK();
-  const tokenizer = await AutoTokenizer.from_pretrained(model.provider_config.model_path, {
-    progress_callback: (progress) => onProgress(progress?.progress ?? 0)
-  });
+  const tokenizer = await AutoTokenizer.from_pretrained(model.provider_config.model_path, {});
   const tokenIds = tokenizer.encode(input.text);
   return { count: tokenIds.length };
+}
+var HFT_CountTokens = async (input, model, _signal, emit) => {
+  const data = await countTokens(input, model);
+  emit({ type: "finish", data });
 };
 var HFT_CountTokens_Preview = async (input, model) => {
-  return HFT_CountTokens(input, model, () => {}, new AbortController().signal);
+  return countTokens(input, model);
 };
 
 // src/ai/common/HFT_Download.ts
 init_HFT_Pipeline();
 import { getLogger as getLogger2 } from "@workglow/util/worker";
-var HFT_Download = async (input, model, onProgress, signal) => {
+var HFT_Download = async (input, model, signal, emit) => {
   const logger = getLogger2();
   const timerLabel = `hft:Download:${model?.provider_config.model_path}`;
   logger.time(timerLabel, { model: model?.provider_config.model_path });
-  await getPipeline(model, onProgress, {}, signal, 100);
+  await getPipeline(model, emit, {}, signal, 100);
   logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
-  return {
-    model: input.model
-  };
+  emit({ type: "finish", data: { model: input.model } });
+};
+
+// src/ai/common/HFT_DownloadRemove.ts
+init_HFT_Pipeline();
+function hasBrowserCacheStorage() {
+  return typeof globalThis !== "undefined" && "caches" in globalThis && typeof globalThis.caches?.open === "function";
+}
+async function deleteModelCacheFromBrowser(model_path) {
+  const cachesApi = globalThis.caches;
+  const cache = await cachesApi.open(HTF_CACHE_NAME);
+  const keys = await cache.keys();
+  const prefix = `/${model_path}/`;
+  const requestsToDelete = [];
+  for (const request of keys) {
+    const url = new URL(request.url);
+    if (url.pathname.startsWith(prefix)) {
+      requestsToDelete.push(request);
+    }
+  }
+  for (const request of requestsToDelete) {
+    try {
+      const deleted = await cache.delete(request);
+      if (!deleted) {
+        const deletedByUrl = await cache.delete(request.url);
+        if (!deletedByUrl) {}
+      }
+    } catch (error) {
+      console.error(`Failed to delete cache entry: ${request.url}`, error);
+    }
+  }
+}
+async function deleteModelCacheFromFilesystem(model) {
+  const { ModelRegistry } = await loadTransformersSDK();
+  const { pipeline: pipelineType, model_path, dtype } = model.provider_config;
+  await ModelRegistry.clear_pipeline_cache(pipelineType, model_path, {
+    ...dtype ? { dtype } : {}
+  });
+}
+var HFT_DownloadRemove = async (input, model, _signal, emit) => {
+  const cacheKey = getPipelineCacheKey(model);
+  await removeCachedPipeline(cacheKey);
+  const model_path = model.provider_config.model_path;
+  disposeHftSessionsForModel(model_path);
+  if (hasBrowserCacheStorage()) {
+    await deleteModelCacheFromBrowser(model_path);
+  } else {
+    await deleteModelCacheFromFilesystem(model);
+  }
+  emit({ type: "finish", data: { model: input.model } });
 };
 
 // src/ai/common/HFT_ImageClassification.ts
 init_HFT_Pipeline();
 import { imageValueToBlob as imageValueToBlob2 } from "@workglow/ai/provider-utils";
-var HFT_ImageClassification = async (input, model, onProgress, signal) => {
+var HFT_ImageClassification = async (input, model, signal, emit) => {
   if (model?.provider_config?.pipeline === "zero-shot-image-classification") {
     if (!input.categories || !Array.isArray(input.categories) || input.categories.length === 0) {
       console.warn("Zero-shot image classification requires categories", input);
       throw new Error("Zero-shot image classification requires categories");
     }
-    const zeroShotClassifier = await getPipeline(model, onProgress, {}, signal);
+    const zeroShotClassifier = await getPipeline(model, emit, {}, signal);
     const imageArg2 = await imageValueToBlob2(input.image);
     const result2 = await zeroShotClassifier(imageArg2, input.categories, {});
     const results2 = Array.isArray(result2) ? result2 : [result2];
-    return {
-      categories: results2.map((r) => ({
-        label: r.label,
-        score: r.score
-      }))
-    };
+    emit({
+      type: "finish",
+      data: {
+        categories: results2.map((r) => ({
+          label: r.label,
+          score: r.score
+        }))
+      }
+    });
+    return;
   }
-  const classifier = await getPipeline(model, onProgress, {}, signal);
+  const classifier = await getPipeline(model, emit, {}, signal);
   const imageArg = await imageValueToBlob2(input.image);
   const result = await classifier(imageArg, {
     top_k: input.maxCategories
   });
   const results = Array.isArray(result) ? result : [result];
-  return {
-    categories: results.map((r) => ({
-      label: r.label,
-      score: r.score
-    }))
-  };
+  emit({
+    type: "finish",
+    data: {
+      categories: results.map((r) => ({
+        label: r.label,
+        score: r.score
+      }))
+    }
+  });
 };
 
 // src/ai/common/HFT_ImageEmbedding.ts
 init_HFT_Pipeline();
 import { getLogger as getLogger3 } from "@workglow/util/worker";
 import { imageValueToBlob as imageValueToBlob3 } from "@workglow/ai/provider-utils";
-var HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
+var HFT_ImageEmbedding = async (input, model, signal, emit) => {
   const logger = getLogger3();
   const timerLabel = `hft:ImageEmbedding:${model?.provider_config.model_path}`;
   logger.time(timerLabel, { model: model?.provider_config.model_path });
-  const embedder = await getPipeline(model, onProgress, {}, signal);
+  const embedder = await getPipeline(model, emit, {}, signal);
   logger.debug("HFT ImageEmbedding: pipeline ready, generating embedding", {
     model: model?.provider_config.model_path
   });
@@ -1369,21 +1291,23 @@ var HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
       vectors.push(result2.data);
     }
     logger.timeEnd(timerLabel, { count: vectors.length });
-    return { vector: vectors };
+    emit({ type: "finish", data: { vector: vectors } });
+    return;
   }
   const imageArg = await imageValueToBlob3(input.image);
   const result = await embedder(imageArg);
   logger.timeEnd(timerLabel, { dimensions: result?.data?.length });
-  return {
-    vector: result.data
-  };
+  emit({
+    type: "finish",
+    data: { vector: result.data }
+  });
 };
 
 // src/ai/common/HFT_ImageSegmentation.ts
 init_HFT_Pipeline();
 import { imageValueToBlob as imageValueToBlob4 } from "@workglow/ai/provider-utils";
-var HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
-  const segmenter = await getPipeline(model, onProgress, {}, signal);
+var HFT_ImageSegmentation = async (input, model, signal, emit) => {
+  const segmenter = await getPipeline(model, emit, {}, signal);
   const imageArg = await imageValueToBlob4(input.image);
   const result = await segmenter(imageArg, {
     threshold: input.threshold,
@@ -1395,30 +1319,36 @@ var HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
     score: mask.score || 0,
     mask: {}
   })));
-  return {
-    masks: processedMasks
-  };
+  emit({
+    type: "finish",
+    data: {
+      masks: processedMasks
+    }
+  });
 };
 
 // src/ai/common/HFT_ImageToText.ts
 init_HFT_Pipeline();
 import { imageValueToBlob as imageValueToBlob5 } from "@workglow/ai/provider-utils";
-var HFT_ImageToText = async (input, model, onProgress, signal) => {
-  const captioner = await getPipeline(model, onProgress, {}, signal);
+var HFT_ImageToText = async (input, model, signal, emit) => {
+  const captioner = await getPipeline(model, emit, {}, signal);
   const imageArg = await imageValueToBlob5(input.image);
   const result = await captioner(imageArg, {
     max_new_tokens: input.maxTokens
   });
   const text = Array.isArray(result[0]) ? result[0][0]?.generated_text : result[0]?.generated_text;
-  return {
-    text: text || ""
-  };
+  emit({
+    type: "finish",
+    data: {
+      text: text || ""
+    }
+  });
 };
 
 // src/ai/common/HFT_ModelInfo.ts
 import { getLogger as getLogger4 } from "@workglow/util/worker";
 init_HFT_Pipeline();
-var HFT_ModelInfo = async (input, model) => {
+var HFT_ModelInfo = async (input, model, _signal, emit) => {
   if (input.detail === "dimensions") {
     if (!model)
       throw new Error("Model config is required for ModelInfoTask.");
@@ -1436,18 +1366,22 @@ var HFT_ModelInfo = async (input, model) => {
         }
       } catch {}
     }
-    return {
-      model: input.model,
-      is_local: true,
-      is_remote: false,
-      supports_browser: true,
-      supports_node: true,
-      is_cached: false,
-      is_loaded: false,
-      file_sizes: null,
-      ...native_dimensions !== undefined ? { native_dimensions } : {},
-      ...mrl ? { mrl } : {}
-    };
+    emit({
+      type: "finish",
+      data: {
+        model: input.model,
+        is_local: true,
+        is_remote: false,
+        supports_browser: true,
+        supports_node: true,
+        is_cached: false,
+        is_loaded: false,
+        file_sizes: null,
+        ...native_dimensions !== undefined ? { native_dimensions } : {},
+        ...mrl ? { mrl } : {}
+      }
+    });
+    return;
   }
   const logger = getLogger4();
   const { ModelRegistry } = await loadTransformersSDK();
@@ -1494,79 +1428,90 @@ var HFT_ModelInfo = async (input, model) => {
     }
   }
   logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
-  return {
-    model: input.model,
-    is_local: true,
-    is_remote: false,
-    supports_browser: true,
-    supports_node: true,
-    is_cached,
-    is_loaded,
-    file_sizes,
-    ...quantizations ? { quantizations } : {}
-  };
+  emit({
+    type: "finish",
+    data: {
+      model: input.model,
+      is_local: true,
+      is_remote: false,
+      supports_browser: true,
+      supports_node: true,
+      is_cached,
+      is_loaded,
+      file_sizes,
+      ...quantizations ? { quantizations } : {}
+    }
+  });
+};
+
+// src/ai/common/HFT_ModelSearch.ts
+import { searchHfModels, mapHfModelResult } from "@workglow/ai/provider-utils";
+var HFT_ModelSearch = async (input, _model, signal, emit) => {
+  const entries = await searchHfModels(input.query?.trim() ?? "", { filter: "onnx" }, ["siblings"], signal);
+  const results = entries.map((entry) => {
+    const item = mapHfModelResult(entry, HF_TRANSFORMERS_ONNX);
+    if (entry.siblings && entry.siblings.length > 0) {
+      const filePaths = entry.siblings.map((s) => s.rfilename);
+      const quantizations = parseOnnxQuantizations({ filePaths });
+      if (quantizations.length > 0) {
+        const record = item.record;
+        const providerConfig = record.provider_config ?? {};
+        providerConfig.quantizations = quantizations;
+        record.provider_config = providerConfig;
+      }
+    }
+    const raw = item.raw;
+    delete raw.siblings;
+    return item;
+  });
+  emit({ type: "finish", data: { results } });
 };
 
 // src/ai/common/HFT_ObjectDetection.ts
 init_HFT_Pipeline();
 import { imageValueToBlob as imageValueToBlob6 } from "@workglow/ai/provider-utils";
-var HFT_ObjectDetection = async (input, model, onProgress, signal) => {
+var HFT_ObjectDetection = async (input, model, signal, emit) => {
   if (model?.provider_config?.pipeline === "zero-shot-object-detection") {
     if (!input.labels || !Array.isArray(input.labels) || input.labels.length === 0) {
       throw new Error("Zero-shot object detection requires labels");
     }
-    const zeroShotDetector = await getPipeline(model, onProgress, {}, signal);
+    const zeroShotDetector = await getPipeline(model, emit, {}, signal);
     const imageArg2 = await imageValueToBlob6(input.image);
     const result = await zeroShotDetector(imageArg2, Array.from(input.labels), {
       threshold: input.threshold
     });
-    return {
-      detections: result.map((d) => ({
-        label: d.label,
-        score: d.score,
-        box: d.box
-      }))
-    };
+    emit({
+      type: "finish",
+      data: {
+        detections: result.map((d) => ({
+          label: d.label,
+          score: d.score,
+          box: d.box
+        }))
+      }
+    });
+    return;
   }
-  const detector = await getPipeline(model, onProgress, {}, signal);
+  const detector = await getPipeline(model, emit, {}, signal);
   const imageArg = await imageValueToBlob6(input.image);
   const detections = await detector(imageArg, {
     threshold: input.threshold
   });
-  return {
-    detections: detections.map((d) => ({
-      label: d.label,
-      score: d.score,
-      box: d.box
-    }))
-  };
+  emit({
+    type: "finish",
+    data: {
+      detections: detections.map((d) => ({
+        label: d.label,
+        score: d.score,
+        box: d.box
+      }))
+    }
+  });
 };
 
 // src/ai/common/HFT_StructuredGeneration.ts
 init_HFT_Pipeline();
 import { parsePartialJson } from "@workglow/util/worker";
-
-// src/ai/common/HFT_TextOutput.ts
-function extractGeneratedText(generatedText) {
-  if (generatedText == null)
-    return "";
-  if (typeof generatedText === "string")
-    return generatedText;
-  const lastMessage = generatedText[generatedText.length - 1];
-  if (!lastMessage)
-    return "";
-  const content = lastMessage.content;
-  if (typeof content === "string")
-    return content;
-  for (const part of content) {
-    if (part.type === "text" && "text" in part) {
-      return part.text;
-    }
-  }
-  return "";
-}
-
-// src/ai/common/HFT_StructuredGeneration.ts
 function buildStructuredGenerationPrompt(input) {
   const schemaStr = JSON.stringify(input.outputSchema, null, 2);
   return `${input.prompt}
@@ -1595,8 +1540,8 @@ function extractJsonFromText(text) {
     return {};
   }
 }
-var HFT_StructuredGeneration = async (input, model, onProgress, signal) => {
-  const generateText = await getPipeline(model, onProgress, {}, signal);
+var HFT_StructuredGeneration = async (input, model, signal, emit) => {
+  const generateText = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
   const prompt = buildStructuredGenerationPrompt(input);
   const messages = [{ role: "user", content: prompt }];
@@ -1604,139 +1549,105 @@ var HFT_StructuredGeneration = async (input, model, onProgress, signal) => {
     tokenize: false,
     add_generation_prompt: true
   });
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
-  let results = await generateText(formattedPrompt, {
-    max_new_tokens: input.maxTokens ?? 1024,
-    temperature: input.temperature ?? undefined,
-    return_full_text: false,
-    streamer,
-    stopping_criteria: [stopping_criteria]
-  });
-  if (!Array.isArray(results)) {
-    results = [results];
-  }
-  const responseText = extractGeneratedText(results[0]?.generated_text).trim();
-  const object = extractJsonFromText(responseText);
-  return { object };
-};
-var HFT_StructuredGeneration_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const generateText = await getPipeline(model, noopProgress, {}, signal);
-  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const prompt = buildStructuredGenerationPrompt(input);
-  const messages = [{ role: "user", content: prompt }];
-  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
-    tokenize: false,
-    add_generation_prompt: true
-  });
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
   let fullText = "";
   let cleanedText = "";
   let inThinkBlock = false;
   let jsonStart = -1;
-  const originalPush = queue.push;
-  queue.push = (event) => {
-    if (event.type === "text-delta" && "textDelta" in event) {
-      const delta = event.textDelta;
-      fullText += delta;
-      let remaining = delta;
-      while (remaining.length > 0) {
-        if (inThinkBlock) {
-          const closeIdx = remaining.indexOf("</think>");
-          if (closeIdx !== -1) {
-            inThinkBlock = false;
-            remaining = remaining.slice(closeIdx + "</think>".length);
-          } else {
-            remaining = "";
-          }
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, (delta) => {
+    fullText += delta;
+    let remaining = delta;
+    while (remaining.length > 0) {
+      if (inThinkBlock) {
+        const closeIdx = remaining.indexOf("</think>");
+        if (closeIdx !== -1) {
+          inThinkBlock = false;
+          remaining = remaining.slice(closeIdx + "</think>".length);
         } else {
-          const openIdx = remaining.indexOf("<think>");
-          if (openIdx !== -1) {
-            cleanedText += remaining.slice(0, openIdx).replace(/<\|[a-z_]+\|>/g, "");
-            inThinkBlock = true;
-            remaining = remaining.slice(openIdx + "<think>".length);
-          } else {
-            cleanedText += remaining.replace(/<\|[a-z_]+\|>/g, "");
-            remaining = "";
-          }
+          remaining = "";
         }
-      }
-      if (jsonStart === -1) {
-        jsonStart = cleanedText.indexOf("{");
-      }
-      if (jsonStart !== -1) {
-        const partial = parsePartialJson(cleanedText.slice(jsonStart));
-        if (partial !== undefined) {
-          originalPush({
-            type: "object-delta",
-            port: "object",
-            objectDelta: partial
-          });
-          return;
+      } else {
+        const openIdx = remaining.indexOf("<think>");
+        if (openIdx !== -1) {
+          cleanedText += remaining.slice(0, openIdx).replace(/<\|[a-z_]+\|>/g, "");
+          inThinkBlock = true;
+          remaining = remaining.slice(openIdx + "<think>".length);
+        } else {
+          cleanedText += remaining.replace(/<\|[a-z_]+\|>/g, "");
+          remaining = "";
         }
       }
     }
-    originalPush(event);
-  };
-  const pipelinePromise = generateText(formattedPrompt, {
+    if (jsonStart === -1) {
+      jsonStart = cleanedText.indexOf("{");
+    }
+    if (jsonStart !== -1) {
+      const partial = parsePartialJson(cleanedText.slice(jsonStart));
+      if (partial !== undefined) {
+        emit({ type: "object-delta", port: "object", objectDelta: partial });
+        return;
+      }
+    }
+    emit({ type: "text-delta", port: "text", textDelta: delta });
+  }, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  await generateText(formattedPrompt, {
     max_new_tokens: input.maxTokens ?? 1024,
     temperature: input.temperature ?? undefined,
     return_full_text: false,
     streamer,
     stopping_criteria: [stopping_criteria]
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
+  });
   const object = extractJsonFromText(fullText);
-  yield { type: "finish", data: { object } };
+  emit({ type: "finish", data: { object } });
 };
 
 // src/ai/common/HFT_TextClassification.ts
 init_HFT_Pipeline();
-var HFT_TextClassification = async (input, model, onProgress, signal) => {
+var HFT_TextClassification = async (input, model, signal, emit) => {
   if (model?.provider_config?.pipeline === "zero-shot-classification") {
     if (!input.candidateLabels || !Array.isArray(input.candidateLabels) || input.candidateLabels.length === 0) {
       throw new Error("Zero-shot text classification requires candidate labels");
     }
-    const zeroShotClassifier = await getPipeline(model, onProgress, {}, signal);
+    const zeroShotClassifier = await getPipeline(model, emit, {}, signal);
     const result2 = await zeroShotClassifier(input.text, input.candidateLabels, {});
-    return {
-      categories: result2.labels.map((label, idx) => ({
-        label,
-        score: result2.scores[idx]
-      }))
-    };
+    emit({
+      type: "finish",
+      data: {
+        categories: result2.labels.map((label, idx) => ({
+          label,
+          score: result2.scores[idx]
+        }))
+      }
+    });
+    return;
   }
-  const TextClassification = await getPipeline(model, onProgress, {}, signal);
+  const TextClassification = await getPipeline(model, emit, {}, signal);
   const result = await TextClassification(input.text, {
     top_k: input.maxCategories || undefined
   });
-  return {
-    categories: result.map((category) => ({
-      label: category.label,
-      score: category.score
-    }))
-  };
+  emit({
+    type: "finish",
+    data: {
+      categories: result.map((category) => ({
+        label: category.label,
+        score: category.score
+      }))
+    }
+  });
 };
 
 // src/ai/common/HFT_TextEmbedding.ts
 init_HFT_Pipeline();
 import { getLogger as getLogger5 } from "@workglow/util/worker";
-var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
+var HFT_TextEmbedding = async (input, model, signal, emit) => {
   const logger = getLogger5();
   const uuid = crypto.randomUUID();
   const timerLabel = `hft:TextEmbedding:${model?.provider_config.model_path}:${uuid}`;
   logger.time(timerLabel, { model: model?.provider_config.model_path });
-  const generateEmbedding = await getPipeline(model, onProgress, {}, signal);
+  const generateEmbedding = await getPipeline(model, emit, {}, signal);
   logger.debug("HFT TextEmbedding: pipeline ready, generating embedding", {
     model: model?.provider_config.model_path,
     inputLength: Array.isArray(input.text) ? input.text.length : input.text?.length
@@ -1757,7 +1668,8 @@ var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
     }
     const vectors = Array.from({ length: numTexts }, (_, i) => hfVector[i].data.slice());
     logger.timeEnd(timerLabel, { batchSize: numTexts, dimensions: vectorDim });
-    return { vector: vectors };
+    emit({ type: "finish", data: { vector: vectors } });
+    return;
   }
   if (hfVector.size !== embeddingDim) {
     logger.timeEnd(timerLabel, { status: "error", reason: "dimension mismatch" });
@@ -1765,38 +1677,32 @@ var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
     throw new Error(`HuggingFace Embedding vector length does not match model dimensions v${hfVector.size} != m${embeddingDim}`);
   }
   logger.timeEnd(timerLabel, { dimensions: hfVector.size });
-  return { vector: hfVector.data };
+  emit({ type: "finish", data: { vector: hfVector.data } });
 };
 
 // src/ai/common/HFT_TextFillMask.ts
 init_HFT_Pipeline();
-var HFT_TextFillMask = async (input, model, onProgress, signal) => {
-  const unmasker = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextFillMask = async (input, model, signal, emit) => {
+  const unmasker = await getPipeline(model, emit, {}, signal);
   const predictions = await unmasker(input.text);
-  return {
-    predictions: predictions.map((prediction) => ({
-      entity: prediction.token_str,
-      score: prediction.score,
-      sequence: prediction.sequence
-    }))
-  };
+  emit({
+    type: "finish",
+    data: {
+      predictions: predictions.map((prediction) => ({
+        entity: prediction.token_str,
+        score: prediction.score,
+        sequence: prediction.sequence
+      }))
+    }
+  });
 };
 
 // src/ai/common/HFT_TextGeneration.ts
 init_HFT_Pipeline();
-import { getLogger as getLogger6 } from "@workglow/util/worker";
-var HFT_TextGeneration = async (input, model, onProgress, signal, _outputSchema, sessionId) => {
-  signal?.throwIfAborted?.();
-  const logger = getLogger6();
-  const timerLabel = `hft:TextGeneration:${model?.provider_config.model_path}`;
-  logger.time(timerLabel, { model: model?.provider_config.model_path });
-  const generateText = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextGeneration = async (input, model, signal, emit, _outputSchema, sessionId) => {
+  const generateText = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  logger.debug("HFT TextGeneration: pipeline ready, generating text", {
-    model: model?.provider_config.model_path,
-    promptLength: input.prompt?.length
-  });
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, (text) => emit({ type: "text-delta", port: "text", textDelta: text }), TextStreamer);
   const stopping_criteria = new InterruptableStoppingCriteria;
   if (signal) {
     signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
@@ -1819,366 +1725,160 @@ var HFT_TextGeneration = async (input, model, onProgress, signal, _outputSchema,
     past_key_values = session.cache;
   }
   const messages = [{ role: "user", content: input.prompt }];
-  let results = await generateText(messages, {
+  await generateText(messages, {
     streamer,
     do_sample: false,
     max_new_tokens: input.maxTokens ?? 4 * 1024,
     stopping_criteria: [stopping_criteria],
     ...past_key_values ? { past_key_values } : {}
   });
-  if (!Array.isArray(results)) {
-    results = [results];
-  }
-  const text = extractGeneratedText(results[0]?.generated_text);
-  logger.timeEnd(timerLabel, { outputLength: text?.length });
-  return {
-    text
-  };
-};
-var HFT_TextGeneration_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
-  const noopProgress = () => {};
-  const generateText = await getPipeline(model, noopProgress, {}, signal);
-  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
-  const modelPath = model.provider_config.model_path;
-  let session = sessionId ? getHftSession(sessionId) : undefined;
-  let past_key_values = undefined;
-  if (sessionId && !session) {
-    const sdk = await loadTransformersSDK();
-    const cache = new sdk.DynamicCache;
-    const newSession = {
-      mode: "progressive",
-      cache,
-      modelPath
-    };
-    setHftSession(sessionId, newSession);
-    session = newSession;
-  }
-  if (session?.mode === "progressive") {
-    past_key_values = session.cache;
-  }
-  const messages = [{ role: "user", content: input.prompt }];
-  const pipelinePromise = generateText(messages, {
-    streamer,
-    do_sample: false,
-    max_new_tokens: input.maxTokens ?? 4 * 1024,
-    stopping_criteria: [stopping_criteria],
-    ...past_key_values ? { past_key_values } : {}
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/HFT_TextLanguageDetection.ts
 init_HFT_Pipeline();
-var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
-  const TextClassification = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextLanguageDetection = async (input, model, signal, emit) => {
+  const TextClassification = await getPipeline(model, emit, {}, signal);
   const result = await TextClassification(input.text, {
     top_k: input.maxLanguages || undefined
   });
-  return {
-    languages: result.map((category) => ({
-      language: category.label,
-      score: category.score
-    }))
-  };
+  emit({
+    type: "finish",
+    data: {
+      languages: result.map((category) => ({
+        language: category.label,
+        score: category.score
+      }))
+    }
+  });
 };
 
 // src/ai/common/HFT_TextNamedEntityRecognition.ts
 init_HFT_Pipeline();
-var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
-  const textNamedEntityRecognition = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextNamedEntityRecognition = async (input, model, signal, emit) => {
+  const textNamedEntityRecognition = await getPipeline(model, emit, {}, signal);
   const results = await textNamedEntityRecognition(input.text, {
     ignore_labels: input.blockList
   });
-  return {
-    entities: results.map((entity) => ({
-      entity: entity.entity,
-      score: entity.score,
-      word: entity.word
-    }))
-  };
+  emit({
+    type: "finish",
+    data: {
+      entities: results.map((entity) => ({
+        entity: entity.entity,
+        score: entity.score,
+        word: entity.word
+      }))
+    }
+  });
 };
 
 // src/ai/common/HFT_TextQuestionAnswer.ts
 init_HFT_Pipeline();
-var HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
-  const generateAnswer = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextQuestionAnswer = async (input, model, signal, emit) => {
+  const generateAnswer = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, (text) => emit({ type: "text-delta", port: "text", textDelta: text }), TextStreamer);
   const stopping_criteria = new InterruptableStoppingCriteria;
   if (signal) {
     signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
   }
-  const result = await generateAnswer(input.question, input.context, {
+  const pipelineResult = await generateAnswer(input.question, input.context, {
     streamer,
     stopping_criteria: [stopping_criteria]
   });
-  const answerText = result?.answer || "";
-  return { text: answerText };
-};
-var HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const generateAnswer = await getPipeline(model, noopProgress, {}, signal);
-  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
-  let pipelineResult;
-  const pipelinePromise = generateAnswer(input.question, input.context, {
-    streamer,
-    stopping_criteria: [stopping_criteria]
-  }).then((result) => {
-    pipelineResult = result;
-    queue.done();
-  }, (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  let answerText = "";
-  if (pipelineResult !== undefined) {
-    if (Array.isArray(pipelineResult)) {
-      answerText = pipelineResult[0]?.answer ?? "";
-    } else {
-      answerText = pipelineResult?.answer ?? "";
-    }
-  }
-  yield { type: "finish", data: { text: answerText } };
+  const answerText = Array.isArray(pipelineResult) ? pipelineResult[0]?.answer ?? "" : pipelineResult?.answer ?? "";
+  emit({ type: "finish", data: { text: answerText } });
 };
 
 // src/ai/common/HFT_TextRewriter.ts
 init_HFT_Pipeline();
-var HFT_TextRewriter = async (input, model, onProgress, signal) => {
-  const generateText = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextRewriter = async (input, model, signal, emit) => {
+  const generateText = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, (text) => emit({ type: "text-delta", port: "text", textDelta: text }), TextStreamer);
   const stopping_criteria = new InterruptableStoppingCriteria;
   if (signal) {
     signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
   }
   const promptedText = (input.prompt ? input.prompt + `
 ` : "") + input.text;
-  let results = await generateText(promptedText, {
+  await generateText(promptedText, {
     streamer,
     stopping_criteria: [stopping_criteria]
   });
-  if (!Array.isArray(results)) {
-    results = [results];
-  }
-  const text = extractGeneratedText(results[0]?.generated_text);
-  if (text === promptedText) {
-    throw new Error("Rewriter failed to generate new text");
-  }
-  return {
-    text
-  };
-};
-var HFT_TextRewriter_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const generateText = await getPipeline(model, noopProgress, {}, signal);
-  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
-  const promptedText = (input.prompt ? input.prompt + `
-` : "") + input.text;
-  const pipelinePromise = generateText(promptedText, {
-    streamer,
-    stopping_criteria: [stopping_criteria]
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/HFT_TextSummary.ts
 init_HFT_Pipeline();
-var HFT_TextSummary = async (input, model, onProgress, signal) => {
-  const generateSummary = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextSummary = async (input, model, signal, emit) => {
+  const generateSummary = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const streamer = createTextStreamer(generateSummary.tokenizer, onProgress, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, (text) => emit({ type: "text-delta", port: "text", textDelta: text }), TextStreamer);
   const stopping_criteria = new InterruptableStoppingCriteria;
   if (signal) {
     signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
   }
-  const result = await generateSummary(input.text, {
+  await generateSummary(input.text, {
     streamer,
     stopping_criteria: [stopping_criteria]
   });
-  let summaryText = "";
-  if (Array.isArray(result)) {
-    summaryText = result[0]?.summary_text || "";
-  } else {
-    summaryText = result?.summary_text || "";
-  }
-  return {
-    text: summaryText
-  };
-};
-var HFT_TextSummary_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const generateSummary = await getPipeline(model, noopProgress, {}, signal);
-  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
-  const pipelinePromise = generateSummary(input.text, {
-    streamer,
-    stopping_criteria: [stopping_criteria]
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/HFT_TextTranslation.ts
 init_HFT_Pipeline();
-var HFT_TextTranslation = async (input, model, onProgress, signal) => {
-  const translate = await getPipeline(model, onProgress, {}, signal);
+var HFT_TextTranslation = async (input, model, signal, emit) => {
+  const translate = await getPipeline(model, emit, {}, signal);
   const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const streamer = createTextStreamer(translate.tokenizer, onProgress, TextStreamer);
+  const streamer = createStreamingTextStreamer(translate.tokenizer, (text) => emit({ type: "text-delta", port: "text", textDelta: text }), TextStreamer);
   const stopping_criteria = new InterruptableStoppingCriteria;
   if (signal) {
     signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
   }
-  const result = await translate(input.text, {
+  await translate(input.text, {
     src_lang: input.source_lang,
     tgt_lang: input.target_lang,
     streamer,
     stopping_criteria: [stopping_criteria]
   });
-  const translatedText = Array.isArray(result) ? result[0]?.translation_text || "" : result?.translation_text || "";
-  return {
-    text: translatedText,
-    target_lang: input.target_lang
-  };
-};
-var HFT_TextTranslation_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const translate = await getPipeline(model, noopProgress, {}, signal);
-  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(translate.tokenizer, queue, TextStreamer);
-  const stopping_criteria = new InterruptableStoppingCriteria;
-  if (signal) {
-    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
-  }
-  const pipelinePromise = translate(input.text, {
-    src_lang: input.source_lang,
-    tgt_lang: input.target_lang,
-    streamer,
-    stopping_criteria: [stopping_criteria]
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  yield { type: "finish", data: { target_lang: input.target_lang } };
+  emit({ type: "finish", data: { target_lang: input.target_lang } });
 };
 
-// src/ai/common/HFT_Unload.ts
-init_HFT_Pipeline();
-function hasBrowserCacheStorage() {
-  return typeof globalThis !== "undefined" && "caches" in globalThis && typeof globalThis.caches?.open === "function";
-}
-async function deleteModelCacheFromBrowser(model_path) {
-  const cachesApi = globalThis.caches;
-  const cache = await cachesApi.open(HTF_CACHE_NAME);
-  const keys = await cache.keys();
-  const prefix = `/${model_path}/`;
-  const requestsToDelete = [];
-  for (const request of keys) {
-    const url = new URL(request.url);
-    if (url.pathname.startsWith(prefix)) {
-      requestsToDelete.push(request);
-    }
-  }
-  for (const request of requestsToDelete) {
-    try {
-      const deleted = await cache.delete(request);
-      if (!deleted) {
-        const deletedByUrl = await cache.delete(request.url);
-        if (!deletedByUrl) {}
-      }
-    } catch (error) {
-      console.error(`Failed to delete cache entry: ${request.url}`, error);
-    }
-  }
-}
-async function deleteModelCacheFromFilesystem(model) {
-  const { ModelRegistry } = await loadTransformersSDK();
-  const { pipeline: pipelineType, model_path, dtype } = model.provider_config;
-  await ModelRegistry.clear_pipeline_cache(pipelineType, model_path, {
-    ...dtype ? { dtype } : {}
-  });
-}
-var HFT_Unload = async (input, model, onProgress, _signal) => {
-  const cacheKey = getPipelineCacheKey(model);
-  if (removeCachedPipeline(cacheKey)) {
-    onProgress(50, "Pipeline removed from memory");
-  }
-  const model_path = model.provider_config.model_path;
-  disposeHftSessionsForModel(model_path);
-  if (hasBrowserCacheStorage()) {
-    await deleteModelCacheFromBrowser(model_path);
+// src/ai/common/HFT_JobRunFns.ts
+var HFT_TextGeneration_Unified = async (input, model, signal, emit, outputSchema, sessionId) => {
+  const maybeMessages = input.messages;
+  if (Array.isArray(maybeMessages) && maybeMessages.length > 0) {
+    await HFT_Chat(input, model, signal, emit, outputSchema, sessionId);
   } else {
-    await deleteModelCacheFromFilesystem(model);
+    await HFT_TextGeneration(input, model, signal, emit, outputSchema, sessionId);
   }
-  onProgress(100, "Model cache deleted");
-  return {
-    model: input.model
-  };
-};
-
-// src/ai/common/HFT_JobRunFns.ts
-var HFT_TASKS = {
-  AiChatTask: HFT_Chat,
-  DownloadModelTask: HFT_Download,
-  UnloadModelTask: HFT_Unload,
-  ModelInfoTask: HFT_ModelInfo,
-  CountTokensTask: HFT_CountTokens,
-  TextEmbeddingTask: HFT_TextEmbedding,
-  TextGenerationTask: HFT_TextGeneration,
-  TextQuestionAnswerTask: HFT_TextQuestionAnswer,
-  TextLanguageDetectionTask: HFT_TextLanguageDetection,
-  TextClassificationTask: HFT_TextClassification,
-  TextFillMaskTask: HFT_TextFillMask,
-  TextNamedEntityRecognitionTask: HFT_TextNamedEntityRecognition,
-  TextRewriterTask: HFT_TextRewriter,
-  TextSummaryTask: HFT_TextSummary,
-  TextTranslationTask: HFT_TextTranslation,
-  ImageSegmentationTask: HFT_ImageSegmentation,
-  ImageToTextTask: HFT_ImageToText,
-  BackgroundRemovalTask: HFT_BackgroundRemoval,
-  ImageEmbeddingTask: HFT_ImageEmbedding,
-  ImageClassificationTask: HFT_ImageClassification,
-  ObjectDetectionTask: HFT_ObjectDetection,
-  ToolCallingTask: HFT_ToolCalling,
-  StructuredGenerationTask: HFT_StructuredGeneration,
-  ModelSearchTask: HFT_ModelSearch
-};
-var HFT_STREAM_TASKS = {
-  AiChatTask: HFT_Chat_Stream,
-  TextGenerationTask: HFT_TextGeneration_Stream,
-  TextRewriterTask: HFT_TextRewriter_Stream,
-  TextSummaryTask: HFT_TextSummary_Stream,
-  TextQuestionAnswerTask: HFT_TextQuestionAnswer_Stream,
-  TextTranslationTask: HFT_TextTranslation_Stream,
-  ToolCallingTask: HFT_ToolCalling_Stream,
-  StructuredGenerationTask: HFT_StructuredGeneration_Stream
 };
+var HFT_RUN_FNS = [
+  { serves: HFT_TEXT_GENERATION, runFn: HFT_TextGeneration_Unified },
+  { serves: HFT_TOOL_USE, runFn: HFT_ToolCalling },
+  { serves: HFT_JSON_MODE, runFn: HFT_StructuredGeneration },
+  { serves: HFT_TEXT_REWRITER, runFn: HFT_TextRewriter },
+  { serves: HFT_TEXT_SUMMARY, runFn: HFT_TextSummary },
+  { serves: HFT_TEXT_TRANSLATION, runFn: HFT_TextTranslation },
+  { serves: HFT_TEXT_QUESTION_ANSWERING, runFn: HFT_TextQuestionAnswer },
+  { serves: HFT_TEXT_EMBEDDING, runFn: HFT_TextEmbedding },
+  { serves: HFT_TEXT_CLASSIFICATION, runFn: HFT_TextClassification },
+  { serves: HFT_TEXT_LANGUAGE_DETECTION, runFn: HFT_TextLanguageDetection },
+  { serves: HFT_TEXT_FILL_MASK, runFn: HFT_TextFillMask },
+  { serves: HFT_TEXT_NER, runFn: HFT_TextNamedEntityRecognition },
+  { serves: HFT_IMAGE_CLASSIFICATION, runFn: HFT_ImageClassification },
+  { serves: HFT_IMAGE_EMBEDDING, runFn: HFT_ImageEmbedding },
+  { serves: HFT_IMAGE_SEGMENTATION, runFn: HFT_ImageSegmentation },
+  { serves: HFT_IMAGE_TO_TEXT, runFn: HFT_ImageToText },
+  { serves: HFT_IMAGE_BACKGROUND_REMOVAL, runFn: HFT_BackgroundRemoval },
+  { serves: HFT_IMAGE_OBJECT_DETECTION, runFn: HFT_ObjectDetection },
+  { serves: HFT_COUNT_TOKENS, runFn: HFT_CountTokens },
+  { serves: HFT_MODEL_DOWNLOAD_REMOVE, runFn: HFT_DownloadRemove },
+  { serves: HFT_MODEL_DOWNLOAD, runFn: HFT_Download },
+  { serves: HFT_MODEL_SEARCH, runFn: HFT_ModelSearch },
+  { serves: HFT_MODEL_INFO, runFn: HFT_ModelInfo }
+];
 var HFT_PREVIEW_TASKS = {
   CountTokensTask: HFT_CountTokens_Preview
 };
@@ -2188,6 +1888,100 @@ init_HFT_Pipeline();
 
 // src/ai/HuggingFaceTransformersQueuedProvider.ts
 import { QueuedAiProvider } from "@workglow/ai";
+
+// src/ai/common/HFT_Capabilities.ts
+var HFT_RUN_FN_SPECS = HFT_CAPABILITY_SETS.map((serves) => ({ serves }));
+function hftWorkerRunFnSpecs() {
+  return HFT_RUN_FN_SPECS;
+}
+function inferHftCapabilities(model) {
+  const declared = model.capabilities ?? [];
+  if (declared.length > 0)
+    return declared;
+  const id = String(model.model_id ?? model.provider_config?.model_path ?? model.provider_config?.model_name ?? "");
+  const pipelineTask = model.provider_config?.pipeline_task ?? "";
+  switch (pipelineTask) {
+    case "text-generation":
+      return [
+        "text.generation",
+        "text.rewriter",
+        "text.summary",
+        "tool-use",
+        "model.count-tokens",
+        "model.download-remove",
+        "model.info",
+        "model.search"
+      ];
+    case "feature-extraction":
+    case "sentence-similarity":
+      return ["text.embedding", "model.download-remove", "model.info", "model.search"];
+    case "text-classification":
+      return ["text.classification", "model.download-remove", "model.info", "model.search"];
+    case "token-classification":
+      return ["text.ner", "model.download-remove", "model.info", "model.search"];
+    case "fill-mask":
+      return ["text.fill-mask", "model.download-remove", "model.info", "model.search"];
+    case "translation":
+      return ["text.translation", "model.download-remove", "model.info", "model.search"];
+    case "summarization":
+      return ["text.summary", "model.download-remove", "model.info", "model.search"];
+    case "question-answering":
+      return ["text.question-answering", "model.download-remove", "model.info", "model.search"];
+    case "image-classification":
+      return ["image.classification", "model.download-remove", "model.info", "model.search"];
+    case "image-segmentation":
+      return ["image.segmentation", "model.download-remove", "model.info", "model.search"];
+    case "image-to-text":
+      return ["image.to-text", "model.download-remove", "model.info", "model.search"];
+    case "object-detection":
+      return ["image.object-detection", "model.download-remove", "model.info", "model.search"];
+    case "zero-shot-image-classification":
+      return [
+        "image.classification",
+        "image.embedding",
+        "model.download-remove",
+        "model.info",
+        "model.search"
+      ];
+  }
+  const baseName = id.split("/").pop() ?? id;
+  if (/embed|minilm|bge-|gte-|e5-/i.test(baseName)) {
+    return ["text.embedding", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/clip|siglip/i.test(baseName)) {
+    return [
+      "image.classification",
+      "image.embedding",
+      "model.download-remove",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/yolo|detr|owl/i.test(baseName)) {
+    return ["image.object-detection", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/sam|segformer|mask/i.test(baseName)) {
+    return ["image.segmentation", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/blip|llava|vision/i.test(baseName)) {
+    return ["image.to-text", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/llama|mistral|gemma|phi|qwen|tinyllama|smollm/i.test(baseName)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "model.count-tokens",
+      "model.download-remove",
+      "model.info",
+      "model.search"
+    ];
+  }
+  return ["model.search", "model.info"];
+}
+
+// src/ai/HuggingFaceTransformersQueuedProvider.ts
 init_HFT_Pipeline();
 var GPU_DEVICES = new Set(["webgpu", "gpu", "metal"]);
 var HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION = 4;
@@ -2217,34 +2011,14 @@ class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
   isLocal = true;
   supportsBrowser = true;
   cpuStrategy;
-  taskTypes = [
-    "AiChatTask",
-    "DownloadModelTask",
-    "UnloadModelTask",
-    "ModelInfoTask",
-    "CountTokensTask",
-    "TextEmbeddingTask",
-    "TextGenerationTask",
-    "TextQuestionAnswerTask",
-    "TextLanguageDetectionTask",
-    "TextClassificationTask",
-    "TextFillMaskTask",
-    "TextNamedEntityRecognitionTask",
-    "TextRewriterTask",
-    "TextSummaryTask",
-    "TextTranslationTask",
-    "ImageSegmentationTask",
-    "ImageToTextTask",
-    "BackgroundRemovalTask",
-    "ImageEmbeddingTask",
-    "ImageClassificationTask",
-    "ObjectDetectionTask",
-    "ToolCallingTask",
-    "StructuredGenerationTask",
-    "ModelSearchTask"
-  ];
-  constructor(tasks, streamTasks, previewTasks) {
-    super(tasks, streamTasks, previewTasks);
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferHftCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return hftWorkerRunFnSpecs();
   }
   createSession(_model) {
     return crypto.randomUUID();
@@ -2269,7 +2043,7 @@ class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
 async function registerHuggingFaceTransformersInline(options) {
   const { env } = await loadTransformersSDK();
   env.backends.onnx.wasm.proxy = true;
-  const provider = new HuggingFaceTransformersQueuedProvider(HFT_TASKS, HFT_STREAM_TASKS, HFT_PREVIEW_TASKS);
+  const provider = new HuggingFaceTransformersQueuedProvider(HFT_RUN_FNS, HFT_PREVIEW_TASKS);
   const baseDispose = provider.dispose.bind(provider);
   provider.dispose = async () => {
     await clearHftInlinePipelineCache();
@@ -2280,7 +2054,6 @@ async function registerHuggingFaceTransformersInline(options) {
 
 // src/ai/registerHuggingFaceTransformersWorker.ts
 import { registerProviderWorker } from "@workglow/ai/provider-utils";
-init_HFT_Pipeline();
 
 // src/ai/HuggingFaceTransformersProvider.ts
 import { AiProvider } from "@workglow/ai/worker";
@@ -2291,34 +2064,14 @@ class HuggingFaceTransformersProvider extends AiProvider {
   displayName = "Hugging Face Transformers (ONNX)";
   isLocal = true;
   supportsBrowser = true;
-  taskTypes = [
-    "AiChatTask",
-    "DownloadModelTask",
-    "UnloadModelTask",
-    "ModelInfoTask",
-    "CountTokensTask",
-    "TextEmbeddingTask",
-    "TextGenerationTask",
-    "TextQuestionAnswerTask",
-    "TextLanguageDetectionTask",
-    "TextClassificationTask",
-    "TextFillMaskTask",
-    "TextNamedEntityRecognitionTask",
-    "TextRewriterTask",
-    "TextSummaryTask",
-    "TextTranslationTask",
-    "ImageSegmentationTask",
-    "ImageToTextTask",
-    "BackgroundRemovalTask",
-    "ImageEmbeddingTask",
-    "ImageClassificationTask",
-    "ObjectDetectionTask",
-    "ToolCallingTask",
-    "StructuredGenerationTask",
-    "ModelSearchTask"
-  ];
-  constructor(tasks, streamTasks, previewTasks) {
-    super(tasks, streamTasks, previewTasks);
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferHftCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return hftWorkerRunFnSpecs();
   }
   createSession(_model) {
     return crypto.randomUUID();
@@ -2329,12 +2082,13 @@ class HuggingFaceTransformersProvider extends AiProvider {
 }
 
 // src/ai/registerHuggingFaceTransformersWorker.ts
+init_HFT_Pipeline();
 async function registerHuggingFaceTransformersWorker() {
   const sdk = await loadTransformersSDK();
   globalThis.__HFT__ = sdk;
   const { env } = sdk;
   env.backends.onnx.wasm.proxy = true;
-  await registerProviderWorker((ws) => new HuggingFaceTransformersProvider(HFT_TASKS, HFT_STREAM_TASKS, HFT_PREVIEW_TASKS).registerOnWorkerServer(ws), "HuggingFaceTransformers");
+  await registerProviderWorker((ws) => new HuggingFaceTransformersProvider(HFT_RUN_FNS, HFT_PREVIEW_TASKS).registerOnWorkerServer(ws), "HuggingFaceTransformers");
 }
 export {
   setHftSession,
@@ -2365,4 +2119,4 @@ export {
   HFT_NULL_PROCESSOR_PREFIX
 };
 
-//# debugId=ABFB8E008DDF9A1264756E2164756E21
+//# debugId=93CB8C37EE02941864756E2164756E21