@workglow/ai-provider 0.0.89 → 0.0.91

package/dist/hf-transformers/index.js

@@ -0,0 +1,1130 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hf-transformers/common/HFT_Constants.ts
+var HF_TRANSFORMERS_ONNX = "HF_TRANSFORMERS_ONNX", HTF_CACHE_NAME = "transformers-cache", QuantizationDataType, TextPipelineUseCase, VisionPipelineUseCase, AudioPipelineUseCase, MultimodalPipelineUseCase, PipelineUseCase;
+var init_HFT_Constants = __esm(() => {
+  QuantizationDataType = {
+    auto: "auto",
+    fp32: "fp32",
+    fp16: "fp16",
+    q8: "q8",
+    int8: "int8",
+    uint8: "uint8",
+    q4: "q4",
+    bnb4: "bnb4",
+    q4f16: "q4f16"
+  };
+  TextPipelineUseCase = {
+    "fill-mask": "fill-mask",
+    "token-classification": "token-classification",
+    "text-generation": "text-generation",
+    "text2text-generation": "text2text-generation",
+    "text-classification": "text-classification",
+    summarization: "summarization",
+    translation: "translation",
+    "feature-extraction": "feature-extraction",
+    "zero-shot-classification": "zero-shot-classification",
+    "question-answering": "question-answering"
+  };
+  VisionPipelineUseCase = {
+    "background-removal": "background-removal",
+    "image-segmentation": "image-segmentation",
+    "depth-estimation": "depth-estimation",
+    "image-classification": "image-classification",
+    "image-to-image": "image-to-image",
+    "object-detection": "object-detection",
+    "image-feature-extraction": "image-feature-extraction"
+  };
+  AudioPipelineUseCase = {
+    "audio-classification": "audio-classification",
+    "automatic-speech-recognition": "automatic-speech-recognition",
+    "text-to-speech": "text-to-speech"
+  };
+  MultimodalPipelineUseCase = {
+    "document-question-answering": "document-question-answering",
+    "image-to-text": "image-to-text",
+    "zero-shot-audio-classification": "zero-shot-audio-classification",
+    "zero-shot-image-classification": "zero-shot-image-classification",
+    "zero-shot-object-detection": "zero-shot-object-detection"
+  };
+  PipelineUseCase = {
+    ...TextPipelineUseCase,
+    ...VisionPipelineUseCase,
+    ...AudioPipelineUseCase,
+    ...MultimodalPipelineUseCase
+  };
+});
+
+// src/hf-transformers/common/HFT_JobRunFns.ts
+var exports_HFT_JobRunFns = {};
+__export(exports_HFT_JobRunFns, {
+  clearPipelineCache: () => clearPipelineCache,
+  HFT_Unload: () => HFT_Unload,
+  HFT_TextTranslation_Stream: () => HFT_TextTranslation_Stream,
+  HFT_TextTranslation: () => HFT_TextTranslation,
+  HFT_TextSummary_Stream: () => HFT_TextSummary_Stream,
+  HFT_TextSummary: () => HFT_TextSummary,
+  HFT_TextRewriter_Stream: () => HFT_TextRewriter_Stream,
+  HFT_TextRewriter: () => HFT_TextRewriter,
+  HFT_TextQuestionAnswer_Stream: () => HFT_TextQuestionAnswer_Stream,
+  HFT_TextQuestionAnswer: () => HFT_TextQuestionAnswer,
+  HFT_TextNamedEntityRecognition: () => HFT_TextNamedEntityRecognition,
+  HFT_TextLanguageDetection: () => HFT_TextLanguageDetection,
+  HFT_TextGeneration_Stream: () => HFT_TextGeneration_Stream,
+  HFT_TextGeneration: () => HFT_TextGeneration,
+  HFT_TextFillMask: () => HFT_TextFillMask,
+  HFT_TextEmbedding: () => HFT_TextEmbedding,
+  HFT_TextClassification: () => HFT_TextClassification,
+  HFT_TASKS: () => HFT_TASKS,
+  HFT_STREAM_TASKS: () => HFT_STREAM_TASKS,
+  HFT_ObjectDetection: () => HFT_ObjectDetection,
+  HFT_ImageToText: () => HFT_ImageToText,
+  HFT_ImageSegmentation: () => HFT_ImageSegmentation,
+  HFT_ImageEmbedding: () => HFT_ImageEmbedding,
+  HFT_ImageClassification: () => HFT_ImageClassification,
+  HFT_Download: () => HFT_Download,
+  HFT_BackgroundRemoval: () => HFT_BackgroundRemoval
+});
+async function loadTransformersSDK() {
+  if (!_transformersSdk) {
+    try {
+      _transformersSdk = await import("@sroussey/transformers");
+    } catch {
+      throw new Error("@sroussey/transformers is required for HuggingFace Transformers tasks. Install it with: bun add @sroussey/transformers");
+    }
+  }
+  return _transformersSdk;
+}
+function clearPipelineCache() {
+  pipelines.clear();
+}
+function getPipelineCacheKey(model) {
+  const dtype = model.provider_config.dtype || "q8";
+  const device = model.provider_config.device || "";
+  return `${model.provider_config.model_path}:${model.provider_config.pipeline}:${dtype}:${device}`;
+}
+function imageToBase64(image) {
+  return image.toBase64?.() || "";
+}
+function createTextStreamer(tokenizer, updateProgress, signal) {
+  const { TextStreamer } = _transformersSdk;
+  let count = 0;
+  return new TextStreamer(tokenizer, {
+    skip_prompt: true,
+    decode_kwargs: { skip_special_tokens: true },
+    callback_function: (text) => {
+      count++;
+      const result = 100 * (1 - Math.exp(-0.05 * count));
+      const progress = Math.round(Math.min(result, 100));
+      updateProgress(progress, "Generating", { text, progress });
+    },
+    ...signal ? { abort_signal: signal } : {}
+  });
+}
+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, signal) {
+  const { TextStreamer } = _transformersSdk;
+  return new TextStreamer(tokenizer, {
+    skip_prompt: true,
+    decode_kwargs: { skip_special_tokens: true },
+    callback_function: (text) => {
+      queue.push({ type: "text-delta", textDelta: text });
+    },
+    ...signal ? { abort_signal: signal } : {}
+  });
+}
+var _transformersSdk, pipelines, getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10) => {
+  const cacheKey = getPipelineCacheKey(model);
+  if (pipelines.has(cacheKey)) {
+    return pipelines.get(cacheKey);
+  }
+  const fileSizes = new Map;
+  const fileProgress = new Map;
+  const fileCompleted = new Set;
+  const fileFirstSent = new Set;
+  const fileLastSent = new Set;
+  const fileLastEventTime = new Map;
+  const pendingProgressByFile = new Map;
+  let throttleTimer = null;
+  const THROTTLE_MS = 160;
+  const estimatedTinyFiles = 3;
+  const estimatedMediumFiles = 1;
+  const estimatedTinySize = 1024;
+  const estimatedMediumSize = 20971520;
+  const estimatedLargeSize = 1073741824;
+  const baseEstimate = estimatedTinyFiles * estimatedTinySize + estimatedMediumFiles * estimatedMediumSize;
+  const sendProgress = (overallProgress, file, fileProgressValue, isFirst, isLast) => {
+    const now = Date.now();
+    const lastTime = fileLastEventTime.get(file) || 0;
+    const timeSinceLastEvent = now - lastTime;
+    const shouldThrottle = !isFirst && !isLast && timeSinceLastEvent < THROTTLE_MS;
+    if (shouldThrottle) {
+      pendingProgressByFile.set(file, {
+        progress: overallProgress,
+        file,
+        fileProgress: fileProgressValue
+      });
+      if (!throttleTimer) {
+        const timeRemaining = Math.max(1, THROTTLE_MS - timeSinceLastEvent);
+        throttleTimer = setTimeout(() => {
+          for (const [pendingFile, pending] of pendingProgressByFile.entries()) {
+            onProgress(Math.round(pending.progress), "Downloading model", {
+              file: pendingFile,
+              progress: pending.fileProgress
+            });
+            fileLastEventTime.set(pendingFile, Date.now());
+          }
+          pendingProgressByFile.clear();
+          throttleTimer = null;
+        }, timeRemaining);
+      }
+      return;
+    }
+    onProgress(Math.round(overallProgress), "Downloading model", {
+      file,
+      progress: fileProgressValue
+    });
+    fileLastEventTime.set(file, now);
+    pendingProgressByFile.delete(file);
+    if (throttleTimer && pendingProgressByFile.size === 0) {
+      clearTimeout(throttleTimer);
+      throttleTimer = null;
+    }
+  };
+  let hasSeenSubstantialFile = false;
+  const substantialFileThreshold = 1048576;
+  const abortSignal = options.abort_signal;
+  const progressCallback = (status) => {
+    if (abortSignal?.aborted) {
+      return;
+    }
+    if (status.status === "progress") {
+      const file = status.file;
+      const fileTotal = status.total;
+      const fileProgressValue = status.progress;
+      if (!fileSizes.has(file)) {
+        fileSizes.set(file, fileTotal);
+        fileProgress.set(file, 0);
+        if (fileTotal >= substantialFileThreshold) {
+          hasSeenSubstantialFile = true;
+        }
+      }
+      fileProgress.set(file, fileProgressValue);
+      const isComplete = fileProgressValue >= 100;
+      if (isComplete && !fileCompleted.has(file)) {
+        fileCompleted.add(file);
+        fileProgress.set(file, 100);
+      }
+      let actualLoadedSize = 0;
+      let actualTotalSize = 0;
+      const tinyThreshold = 102400;
+      const mediumThreshold = 104857600;
+      let seenTinyCount = 0;
+      let seenMediumCount = 0;
+      let seenLargeCount = 0;
+      for (const [trackedFile, size] of fileSizes.entries()) {
+        actualTotalSize += size;
+        const progress = fileProgress.get(trackedFile) || 0;
+        actualLoadedSize += size * progress / 100;
+        if (size < tinyThreshold) {
+          seenTinyCount++;
+        } else if (size < mediumThreshold) {
+          seenMediumCount++;
+        } else {
+          seenLargeCount++;
+        }
+      }
+      const unseenTinyFiles = Math.max(0, estimatedTinyFiles - seenTinyCount);
+      const unseenMediumFiles = Math.max(0, estimatedMediumFiles - seenMediumCount);
+      let estimatedLargeFiles;
+      if (seenLargeCount > 0) {
+        estimatedLargeFiles = 2;
+      } else {
+        estimatedLargeFiles = 1;
+      }
+      const unseenLargeFiles = Math.max(0, estimatedLargeFiles - seenLargeCount);
+      const adjustedTotalSize = actualTotalSize + unseenTinyFiles * estimatedTinySize + unseenMediumFiles * estimatedMediumSize + unseenLargeFiles * estimatedLargeSize;
+      const rawProgress = adjustedTotalSize > 0 ? actualLoadedSize / adjustedTotalSize * 100 : 0;
+      const overallProgress = rawProgress * progressScaleMax / 100;
+      const isFirst = !fileFirstSent.has(file);
+      const isLast = isComplete && !fileLastSent.has(file);
+      if (isFirst) {
+        fileFirstSent.add(file);
+      }
+      if (isLast) {
+        fileLastSent.add(file);
+      }
+      if (hasSeenSubstantialFile) {
+        sendProgress(overallProgress, file, fileProgressValue, isFirst, isLast);
+      }
+    } else if (status.status === "done" || status.status === "download") {
+      const file = status.file;
+      const fileSize = fileSizes.get(file) || 0;
+      if (fileSize >= substantialFileThreshold) {
+        hasSeenSubstantialFile = true;
+      }
+      if (!fileCompleted.has(file)) {
+        fileCompleted.add(file);
+        fileProgress.set(file, 100);
+        let actualLoadedSize = 0;
+        let actualTotalSize = 0;
+        const tinyThreshold = 102400;
+        const mediumThreshold = 104857600;
+        let seenTinyCount = 0;
+        let seenMediumCount = 0;
+        let seenLargeCount = 0;
+        for (const [trackedFile, size] of fileSizes.entries()) {
+          actualTotalSize += size;
+          const progress = fileProgress.get(trackedFile) || 0;
+          actualLoadedSize += size * progress / 100;
+          if (size < tinyThreshold) {
+            seenTinyCount++;
+          } else if (size < mediumThreshold) {
+            seenMediumCount++;
+          } else {
+            seenLargeCount++;
+          }
+        }
+        const unseenTinyFiles = Math.max(0, estimatedTinyFiles - seenTinyCount);
+        const unseenMediumFiles = Math.max(0, estimatedMediumFiles - seenMediumCount);
+        let estimatedLargeFiles;
+        if (seenLargeCount > 0) {
+          estimatedLargeFiles = 2;
+        } else {
+          estimatedLargeFiles = 1;
+        }
+        const unseenLargeFiles = Math.max(0, estimatedLargeFiles - seenLargeCount);
+        const adjustedTotalSize = actualTotalSize + unseenTinyFiles * estimatedTinySize + unseenMediumFiles * estimatedMediumSize + unseenLargeFiles * estimatedLargeSize;
+        const rawProgress = adjustedTotalSize > 0 ? actualLoadedSize / adjustedTotalSize * 100 : 0;
+        const overallProgress = rawProgress * progressScaleMax / 100;
+        const isLast = !fileLastSent.has(file);
+        if (isLast) {
+          fileLastSent.add(file);
+          if (hasSeenSubstantialFile) {
+            sendProgress(overallProgress, file, 100, false, true);
+          }
+        }
+      }
+    }
+  };
+  const pipelineOptions = {
+    dtype: model.provider_config.dtype || "q8",
+    ...model.provider_config.use_external_data_format ? { useExternalDataFormat: model.provider_config.use_external_data_format } : {},
+    ...model.provider_config.device ? { device: model.provider_config.device } : {},
+    ...options,
+    progress_callback: progressCallback
+  };
+  if (abortSignal?.aborted) {
+    throw new Error("Operation aborted before pipeline creation");
+  }
+  const pipelineType = model.provider_config.pipeline;
+  const abortPromise = new Promise((_, reject) => {
+    if (abortSignal) {
+      const handleAbort = () => {
+        reject(new Error("Pipeline download aborted"));
+      };
+      if (abortSignal.aborted) {
+        handleAbort();
+      } else {
+        abortSignal.addEventListener("abort", handleAbort, { once: true });
+      }
+    }
+  });
+  const { pipeline } = await loadTransformersSDK();
+  const pipelinePromise = pipeline(pipelineType, model.provider_config.model_path, pipelineOptions);
+  try {
+    const result = await (abortSignal ? Promise.race([pipelinePromise, abortPromise]) : pipelinePromise);
+    if (abortSignal?.aborted) {
+      throw new Error("Operation aborted after pipeline creation");
+    }
+    pipelines.set(cacheKey, result);
+    return result;
+  } catch (error) {
+    if (abortSignal?.aborted) {
+      throw new Error("Pipeline download aborted");
+    }
+    throw error;
+  }
+}, HFT_Download = async (input, model, onProgress, signal) => {
+  await getPipeline(model, onProgress, { abort_signal: signal }, 100);
+  return {
+    model: input.model
+  };
+}, HFT_Unload = async (input, model, onProgress, signal) => {
+  const cacheKey = getPipelineCacheKey(model);
+  if (pipelines.has(cacheKey)) {
+    pipelines.delete(cacheKey);
+    onProgress(50, "Pipeline removed from memory");
+  }
+  const model_path = model.provider_config.model_path;
+  await deleteModelCache(model_path);
+  onProgress(100, "Model cache deleted");
+  return {
+    model: input.model
+  };
+}, deleteModelCache = async (model_path) => {
+  const cache = await caches.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);
+    }
+  }
+  let deletedCount = 0;
+  for (const request of requestsToDelete) {
+    try {
+      const deleted = await cache.delete(request);
+      if (deleted) {
+        deletedCount++;
+      } else {
+        const deletedByUrl = await cache.delete(request.url);
+        if (deletedByUrl) {
+          deletedCount++;
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to delete cache entry: ${request.url}`, error);
+    }
+  }
+}, HFT_TextEmbedding = async (input, model, onProgress, signal) => {
+  const generateEmbedding = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const hfVector = await generateEmbedding(input.text, {
+    pooling: model?.provider_config.pooling || "mean",
+    normalize: model?.provider_config.normalize,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  const isArrayInput = Array.isArray(input.text);
+  const embeddingDim = model?.provider_config.native_dimensions;
+  if (isArrayInput && hfVector.dims.length > 1) {
+    const [numTexts, vectorDim] = hfVector.dims;
+    if (numTexts !== input.text.length) {
+      throw new Error(`HuggingFace Embedding tensor batch size does not match input array length: ${numTexts} != ${input.text.length}`);
+    }
+    if (vectorDim !== embeddingDim) {
+      throw new Error(`HuggingFace Embedding vector dimension does not match model dimensions: ${vectorDim} != ${embeddingDim}`);
+    }
+    const vectors = Array.from({ length: numTexts }, (_, i) => hfVector[i].data);
+    return { vector: vectors };
+  }
+  if (hfVector.size !== embeddingDim) {
+    console.warn(`HuggingFace Embedding vector length does not match model dimensions v${hfVector.size} != m${embeddingDim}`, input, hfVector);
+    throw new Error(`HuggingFace Embedding vector length does not match model dimensions v${hfVector.size} != m${embeddingDim}`);
+  }
+  return { vector: hfVector.data };
+}, HFT_TextClassification = async (input, model, onProgress, signal) => {
+  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, {
+      abort_signal: signal
+    });
+    const result2 = await zeroShotClassifier(input.text, input.candidateLabels, {});
+    return {
+      categories: result2.labels.map((label, idx) => ({
+        label,
+        score: result2.scores[idx]
+      }))
+    };
+  }
+  const TextClassification = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await TextClassification(input.text, {
+    top_k: input.maxCategories || undefined,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  if (Array.isArray(result[0])) {
+    return {
+      categories: result[0].map((category) => ({
+        label: category.label,
+        score: category.score
+      }))
+    };
+  }
+  return {
+    categories: result.map((category) => ({
+      label: category.label,
+      score: category.score
+    }))
+  };
+}, HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
+  const TextClassification = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await TextClassification(input.text, {
+    top_k: input.maxLanguages || undefined,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  if (Array.isArray(result[0])) {
+    return {
+      languages: result[0].map((category) => ({
+        language: category.label,
+        score: category.score
+      }))
+    };
+  }
+  return {
+    languages: result.map((category) => ({
+      language: category.label,
+      score: category.score
+    }))
+  };
+}, HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
+  const textNamedEntityRecognition = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  let results = await textNamedEntityRecognition(input.text, {
+    ignore_labels: input.blockList,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  let entities = [];
+  if (!Array.isArray(results)) {
+    entities = [results];
+  } else {
+    entities = results;
+  }
+  return {
+    entities: entities.map((entity) => ({
+      entity: entity.entity,
+      score: entity.score,
+      word: entity.word
+    }))
+  };
+}, HFT_TextFillMask = async (input, model, onProgress, signal) => {
+  const unmasker = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  let results = await unmasker(input.text);
+  let predictions = [];
+  if (!Array.isArray(results)) {
+    predictions = [results];
+  } else {
+    predictions = results;
+  }
+  return {
+    predictions: predictions.map((prediction) => ({
+      entity: prediction.token_str,
+      score: prediction.score,
+      sequence: prediction.sequence
+    }))
+  };
+}, HFT_TextGeneration = async (input, model, onProgress, signal) => {
+  const generateText = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, signal);
+  let results = await generateText(input.prompt, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  if (!Array.isArray(results)) {
+    results = [results];
+  }
+  let text = results[0]?.generated_text;
+  if (Array.isArray(text)) {
+    text = text[text.length - 1]?.content;
+  }
+  return {
+    text
+  };
+}, HFT_TextTranslation = async (input, model, onProgress, signal) => {
+  const translate = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const streamer = createTextStreamer(translate.tokenizer, onProgress);
+  const result = await translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  const translatedText = Array.isArray(result) ? result[0]?.translation_text || "" : result?.translation_text || "";
+  return {
+    text: translatedText,
+    target_lang: input.target_lang
+  };
+}, HFT_TextRewriter = async (input, model, onProgress, signal) => {
+  const generateText = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress);
+  const promptedText = (input.prompt ? input.prompt + `
+` : "") + input.text;
+  let results = await generateText(promptedText, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  if (!Array.isArray(results)) {
+    results = [results];
+  }
+  let text = results[0]?.generated_text;
+  if (Array.isArray(text)) {
+    text = text[text.length - 1]?.content;
+  }
+  if (text === promptedText) {
+    throw new Error("Rewriter failed to generate new text");
+  }
+  return {
+    text
+  };
+}, HFT_TextSummary = async (input, model, onProgress, signal) => {
+  const generateSummary = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const streamer = createTextStreamer(generateSummary.tokenizer, onProgress);
+  let result = await generateSummary(input.text, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  let summaryText = "";
+  if (Array.isArray(result)) {
+    summaryText = result[0]?.summary_text || "";
+  } else {
+    summaryText = result?.summary_text || "";
+  }
+  return {
+    text: summaryText
+  };
+}, HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
+  const generateAnswer = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress);
+  const result = await generateAnswer(input.question, input.context, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  let answerText = "";
+  if (Array.isArray(result)) {
+    answerText = result[0]?.answer || "";
+  } else {
+    answerText = result?.answer || "";
+  }
+  return {
+    text: answerText
+  };
+}, HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
+  const segmenter = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await segmenter(input.image, {
+    threshold: input.threshold,
+    mask_threshold: input.maskThreshold,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  const masks = Array.isArray(result) ? result : [result];
+  const processedMasks = await Promise.all(masks.map(async (mask) => ({
+    label: mask.label || "",
+    score: mask.score || 0,
+    mask: {}
+  })));
+  return {
+    masks: processedMasks
+  };
+}, HFT_ImageToText = async (input, model, onProgress, signal) => {
+  const captioner = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await captioner(input.image, {
+    max_new_tokens: input.maxTokens,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  const text = Array.isArray(result) ? result[0]?.generated_text : result?.generated_text;
+  return {
+    text: text || ""
+  };
+}, HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
+  const remover = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await remover(input.image, {
+    ...signal ? { abort_signal: signal } : {}
+  });
+  const resultImage = Array.isArray(result) ? result[0] : result;
+  return {
+    image: imageToBase64(resultImage)
+  };
+}, HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
+  const embedder = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await embedder(input.image);
+  return {
+    vector: result.data
+  };
+}, HFT_ImageClassification = async (input, model, onProgress, signal) => {
+  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, {
+      abort_signal: signal
+    });
+    const result2 = await zeroShotClassifier(input.image, input.categories, {});
+    const results2 = Array.isArray(result2) ? result2 : [result2];
+    return {
+      categories: results2.map((r) => ({
+        label: r.label,
+        score: r.score
+      }))
+    };
+  }
+  const classifier = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await classifier(input.image, {
+    top_k: input.maxCategories,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  const results = Array.isArray(result) ? result : [result];
+  return {
+    categories: results.map((r) => ({
+      label: r.label,
+      score: r.score
+    }))
+  };
+}, HFT_ObjectDetection = async (input, model, onProgress, signal) => {
+  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, {
+      abort_signal: signal
+    });
+    const result2 = await zeroShotDetector(input.image, Array.from(input.labels), {
+      threshold: input.threshold
+    });
+    const detections2 = Array.isArray(result2) ? result2 : [result2];
+    return {
+      detections: detections2.map((d) => ({
+        label: d.label,
+        score: d.score,
+        box: d.box
+      }))
+    };
+  }
+  const detector = await getPipeline(model, onProgress, {
+    abort_signal: signal
+  });
+  const result = await detector(input.image, {
+    threshold: input.threshold,
+    ...signal ? { abort_signal: signal } : {}
+  });
+  const detections = Array.isArray(result) ? result : [result];
+  return {
+    detections: detections.map((d) => ({
+      label: d.label,
+      score: d.score,
+      box: d.box
+    }))
+  };
+}, HFT_TextGeneration_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, signal);
+  const pipelinePromise = generateText(input.prompt, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+}, HFT_TextRewriter_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue);
+  const promptedText = (input.prompt ? input.prompt + `
+` : "") + input.text;
+  const pipelinePromise = generateText(promptedText, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+}, HFT_TextSummary_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateSummary = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue);
+  const pipelinePromise = generateSummary(input.text, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+}, HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateAnswer = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue);
+  let pipelineResult;
+  const pipelinePromise = generateAnswer(input.question, input.context, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).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 } };
+}, HFT_TextTranslation_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const translate = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(translate.tokenizer, queue);
+  const pipelinePromise = translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: { target_lang: input.target_lang } };
+}, HFT_TASKS, HFT_STREAM_TASKS;
+var init_HFT_JobRunFns = __esm(() => {
+  init_HFT_Constants();
+  pipelines = new Map;
+  HFT_TASKS = {
+    DownloadModelTask: HFT_Download,
+    UnloadModelTask: HFT_Unload,
+    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
+  };
+  HFT_STREAM_TASKS = {
+    TextGenerationTask: HFT_TextGeneration_Stream,
+    TextRewriterTask: HFT_TextRewriter_Stream,
+    TextSummaryTask: HFT_TextSummary_Stream,
+    TextQuestionAnswerTask: HFT_TextQuestionAnswer_Stream,
+    TextTranslationTask: HFT_TextTranslation_Stream
+  };
+});
+
+// src/hf-transformers/index.ts
+init_HFT_Constants();
+init_HFT_JobRunFns();
+
+// src/hf-transformers/common/HFT_ModelSchema.ts
+init_HFT_Constants();
+import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai";
+var HfTransformersOnnxModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: HF_TRANSFORMERS_ONNX,
+      description: "Discriminator: ONNX runtime backend."
+    },
+    provider_config: {
+      type: "object",
+      description: "ONNX runtime-specific options.",
+      properties: {
+        pipeline: {
+          type: "string",
+          enum: Object.values(PipelineUseCase),
+          description: "Pipeline type for the ONNX model.",
+          default: "text-generation"
+        },
+        model_path: {
+          type: "string",
+          description: "Filesystem path or URI for the ONNX model."
+        },
+        dtype: {
+          type: "string",
+          enum: Object.values(QuantizationDataType),
+          description: "Data type for the ONNX model.",
+          default: "auto"
+        },
+        device: {
+          type: "string",
+          enum: ["cpu", "gpu", "webgpu", "wasm", "metal"],
+          description: "High-level device selection.",
+          default: "webgpu"
+        },
+        execution_providers: {
+          type: "array",
+          items: { type: "string" },
+          description: "Raw ONNX Runtime execution provider identifiers.",
+          "x-ui-hidden": true
+        },
+        intra_op_num_threads: {
+          type: "integer",
+          minimum: 1
+        },
+        inter_op_num_threads: {
+          type: "integer",
+          minimum: 1
+        },
+        use_external_data_format: {
+          type: "boolean",
+          description: "Whether the model uses external data format."
+        },
+        native_dimensions: {
+          type: "integer",
+          description: "The native dimensions of the model."
+        },
+        pooling: {
+          type: "string",
+          enum: ["mean", "last_token", "cls"],
+          description: "The pooling strategy to use for the model.",
+          default: "mean"
+        },
+        normalize: {
+          type: "boolean",
+          description: "Whether the model uses normalization.",
+          default: true
+        },
+        language_style: {
+          type: "string",
+          description: "The language style of the model."
+        },
+        mrl: {
+          type: "boolean",
+          description: "Whether the model uses matryoshka.",
+          default: false
+        }
+      },
+      required: ["model_path", "pipeline"],
+      additionalProperties: false,
+      if: {
+        properties: {
+          pipeline: {
+            const: "feature-extraction"
+          }
+        }
+      },
+      then: {
+        required: ["native_dimensions"]
+      }
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var HfTransformersOnnxModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...HfTransformersOnnxModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...HfTransformersOnnxModelSchema.required],
+  additionalProperties: false
+};
+var HfTransformersOnnxModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...HfTransformersOnnxModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...HfTransformersOnnxModelSchema.required],
+  additionalProperties: false
+};
+// src/hf-transformers/HFT_Worker.ts
+init_HFT_JobRunFns();
+import { globalServiceRegistry, parentPort, WORKER_SERVER } from "@workglow/util";
+
+// src/hf-transformers/HuggingFaceTransformersProvider.ts
+init_HFT_Constants();
+import {
+  AiProvider
+} from "@workglow/ai";
+
+class HuggingFaceTransformersProvider extends AiProvider {
+  name = HF_TRANSFORMERS_ONNX;
+  taskTypes = [
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "TextEmbeddingTask",
+    "TextGenerationTask",
+    "TextQuestionAnswerTask",
+    "TextLanguageDetectionTask",
+    "TextClassificationTask",
+    "TextFillMaskTask",
+    "TextNamedEntityRecognitionTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "TextTranslationTask",
+    "ImageSegmentationTask",
+    "ImageToTextTask",
+    "BackgroundRemovalTask",
+    "ImageEmbeddingTask",
+    "ImageClassificationTask",
+    "ObjectDetectionTask"
+  ];
+  constructor(tasks, streamTasks) {
+    super(tasks, streamTasks);
+  }
+  async onInitialize(options) {
+    if (options.mode === "inline") {
+      const { env } = await import("@sroussey/transformers");
+      env.backends.onnx.wasm.proxy = true;
+    }
+  }
+  async dispose() {
+    if (this.tasks) {
+      const { clearPipelineCache: clearPipelineCache2 } = await Promise.resolve().then(() => (init_HFT_JobRunFns(), exports_HFT_JobRunFns));
+      clearPipelineCache2();
+    }
+  }
+}
+
+// src/hf-transformers/HFT_Worker.ts
+function HFT_WORKER_JOBRUN_REGISTER() {
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  new HuggingFaceTransformersProvider(HFT_TASKS, HFT_STREAM_TASKS).registerOnWorkerServer(workerServer);
+  parentPort.postMessage({ type: "ready" });
+  console.log("HFT_WORKER_JOBRUN registered");
+}
+export {
+  clearPipelineCache,
+  VisionPipelineUseCase,
+  TextPipelineUseCase,
+  QuantizationDataType,
+  PipelineUseCase,
+  MultimodalPipelineUseCase,
+  HuggingFaceTransformersProvider,
+  HfTransformersOnnxModelSchema,
+  HfTransformersOnnxModelRecordSchema,
+  HfTransformersOnnxModelConfigSchema,
+  HTF_CACHE_NAME,
+  HF_TRANSFORMERS_ONNX,
+  HFT_WORKER_JOBRUN_REGISTER,
+  HFT_Unload,
+  HFT_TextTranslation_Stream,
+  HFT_TextTranslation,
+  HFT_TextSummary_Stream,
+  HFT_TextSummary,
+  HFT_TextRewriter_Stream,
+  HFT_TextRewriter,
+  HFT_TextQuestionAnswer_Stream,
+  HFT_TextQuestionAnswer,
+  HFT_TextNamedEntityRecognition,
+  HFT_TextLanguageDetection,
+  HFT_TextGeneration_Stream,
+  HFT_TextGeneration,
+  HFT_TextFillMask,
+  HFT_TextEmbedding,
+  HFT_TextClassification,
+  HFT_TASKS,
+  HFT_STREAM_TASKS,
+  HFT_ObjectDetection,
+  HFT_ImageToText,
+  HFT_ImageSegmentation,
+  HFT_ImageEmbedding,
+  HFT_ImageClassification,
+  HFT_Download,
+  HFT_BackgroundRemoval,
+  AudioPipelineUseCase
+};
+
+//# debugId=778CAE4E83EF216464756E2164756E21