@workglow/ai-provider 0.0.96 → 0.0.98

package/dist/index-2pvfsjyx.js

@@ -0,0 +1,857 @@
+import {
+  HTF_CACHE_NAME
+} from "./index-m0r2hvfz.js";
+import {
+  __require
+} from "./index-jd3bbc2x.js";
+
+// src/hf-transformers/common/HFT_JobRunFns.ts
+var _transformersSdk;
+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;
+}
+var pipelines = new Map;
+var pipelineLoadPromises = new Map;
+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}`;
+}
+var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10) => {
+  const cacheKey = getPipelineCacheKey(model);
+  if (pipelines.has(cacheKey)) {
+    return pipelines.get(cacheKey);
+  }
+  const inFlight = pipelineLoadPromises.get(cacheKey);
+  if (inFlight) {
+    await inFlight;
+    const cached = pipelines.get(cacheKey);
+    if (cached)
+      return cached;
+  }
+  const loadPromise = doGetPipeline(model, onProgress, options, progressScaleMax, cacheKey).finally(() => {
+    pipelineLoadPromises.delete(cacheKey);
+  });
+  pipelineLoadPromises.set(cacheKey, loadPromise);
+  return loadPromise;
+};
+var doGetPipeline = async (model, onProgress, options, progressScaleMax, 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;
+  }
+};
+var HFT_Download = async (input, model, onProgress, signal) => {
+  await getPipeline(model, onProgress, { abort_signal: signal }, 100);
+  return {
+    model: input.model
+  };
+};
+var 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
+  };
+};
+var 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);
+    }
+  }
+};
+var 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 };
+};
+var 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
+    }))
+  };
+};
+var 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
+    }))
+  };
+};
+var 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
+    }))
+  };
+};
+var 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
+    }))
+  };
+};
+var 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
+  };
+};
+var 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
+  };
+};
+var 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
+  };
+};
+var 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
+  };
+};
+var 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
+  };
+};
+var 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
+  };
+};
+var 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 || ""
+  };
+};
+var 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)
+  };
+};
+var 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
+  };
+};
+var 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
+    }))
+  };
+};
+var 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
+    }))
+  };
+};
+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", port: "text", textDelta: text });
+    },
+    ...signal ? { abort_signal: signal } : {}
+  });
+}
+var 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: {} };
+};
+var 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: {} };
+};
+var 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: {} };
+};
+var 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 } };
+};
+var 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 } };
+};
+var 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
+};
+var HFT_STREAM_TASKS = {
+  TextGenerationTask: HFT_TextGeneration_Stream,
+  TextRewriterTask: HFT_TextRewriter_Stream,
+  TextSummaryTask: HFT_TextSummary_Stream,
+  TextQuestionAnswerTask: HFT_TextQuestionAnswer_Stream,
+  TextTranslationTask: HFT_TextTranslation_Stream
+};
+
+export { clearPipelineCache, HFT_Download, HFT_Unload, HFT_TextEmbedding, HFT_TextClassification, HFT_TextLanguageDetection, HFT_TextNamedEntityRecognition, HFT_TextFillMask, HFT_TextGeneration, HFT_TextTranslation, HFT_TextRewriter, HFT_TextSummary, HFT_TextQuestionAnswer, HFT_ImageSegmentation, HFT_ImageToText, HFT_BackgroundRemoval, HFT_ImageEmbedding, HFT_ImageClassification, HFT_ObjectDetection, HFT_TextGeneration_Stream, HFT_TextRewriter_Stream, HFT_TextSummary_Stream, HFT_TextQuestionAnswer_Stream, HFT_TextTranslation_Stream, HFT_TASKS, HFT_STREAM_TASKS };
+
+//# debugId=4AF2ECA21E0D4F3464756E2164756E21