@workglow/huggingface-transformers 0.2.34 → 0.2.36

package/dist/ai.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) {
@@ -475,7 +469,6 @@ var PipelineUseCase = {
   ...AudioPipelineUseCase,
   ...MultimodalPipelineUseCase
 };
-
 // src/ai/common/HFT_ModelSchema.ts
 import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai/worker";
 var HfTransformersOnnxModelSchema = {
@@ -599,138 +592,6 @@ var HfTransformersOnnxModelConfigSchema = {
   required: [...ModelConfigSchema.required, ...HfTransformersOnnxModelSchema.required],
   additionalProperties: false
 };
-
-// src/ai/HuggingFaceTransformersProvider.ts
-import { AiProvider } from "@workglow/ai/worker";
-init_HFT_Pipeline();
-
-class HuggingFaceTransformersProvider extends AiProvider {
-  name = HF_TRANSFORMERS_ONNX;
-  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);
-  }
-  createSession(_model) {
-    return crypto.randomUUID();
-  }
-  async disposeSession(sessionId) {
-    deleteHftSession(sessionId);
-  }
-}
-
-// src/ai/HuggingFaceTransformersQueuedProvider.ts
-import { QueuedAiProvider } from "@workglow/ai";
-init_HFT_Pipeline();
-var GPU_DEVICES = new Set(["webgpu", "gpu", "metal"]);
-var HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION = 4;
-function hftIsAutomatedTestEnvironment() {
-  if (typeof process === "undefined") {
-    return false;
-  }
-  const e = process.env;
-  return e.VITEST === "true" || e.NODE_ENV === "test" || e.BUN_TEST === "1" || e.JEST_WORKER_ID !== undefined;
-}
-function hftDefaultCpuQueueConcurrency() {
-  return hftIsAutomatedTestEnvironment() ? 1 : HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION;
-}
-function resolveHftCpuQueueConcurrency(concurrency, defaultCpu) {
-  if (concurrency === undefined) {
-    return defaultCpu();
-  }
-  if (typeof concurrency === "number") {
-    return defaultCpu();
-  }
-  return concurrency.cpu ?? defaultCpu();
-}
-
-class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
-  name = HF_TRANSFORMERS_ONNX;
-  displayName = "Hugging Face Transformers (ONNX)";
-  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);
-  }
-  createSession(_model) {
-    return crypto.randomUUID();
-  }
-  async disposeSession(sessionId) {
-    deleteHftSession(sessionId);
-  }
-  async afterRegister(options) {
-    await super.afterRegister(options);
-    this.cpuStrategy = this.createQueuedStrategy(HF_TRANSFORMERS_ONNX_CPU, resolveHftCpuQueueConcurrency(options.queue?.concurrency, hftDefaultCpuQueueConcurrency), options);
-  }
-  getStrategyForModel(model) {
-    const device = model.provider_config?.device;
-    if (device && GPU_DEVICES.has(device)) {
-      return this.queuedStrategy;
-    }
-    return this.cpuStrategy;
-  }
-}
-
-// src/ai/registerHuggingFaceTransformers.ts
-import { registerProviderWithWorker } from "@workglow/ai/provider-utils";
-async function registerHuggingFaceTransformers(options) {
-  await registerProviderWithWorker(new HuggingFaceTransformersQueuedProvider, "HuggingFaceTransformers", options);
-}
-
 // src/ai/common/HFT_OnnxDtypes.ts
 var ONNX_QUANTIZATION_SUFFIX_MAPPING = {
   fp32: "",
@@ -792,7 +653,6 @@ function parseOnnxQuantizations(params) {
     return set !== undefined && set.size === allBaseNames.size;
   });
 }
-
 // src/ai/common/HFT_ToolMarkup.ts
 function createToolCallMarkupFilter(emit) {
   const OPEN_TAG = "<tool_call>";
@@ -858,10 +718,1401 @@ function createToolCallMarkupFilter(emit) {
   }
   return { feed, flush };
 }
+// src/ai/HuggingFaceTransformersProvider.ts
+import { AiProvider } from "@workglow/ai/worker";
+
+// 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_RERANKING = ["text.reranking"];
+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_RERANKING,
+  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_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/HuggingFaceTransformersProvider.ts
+init_HFT_Pipeline();
+
+class HuggingFaceTransformersProvider extends AiProvider {
+  name = HF_TRANSFORMERS_ONNX;
+  displayName = "Hugging Face Transformers (ONNX)";
+  isLocal = true;
+  supportsBrowser = true;
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferHftCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return hftWorkerRunFnSpecs();
+  }
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(sessionId) {
+    deleteHftSession(sessionId);
+  }
+}
+// src/ai/HuggingFaceTransformersQueuedProvider.ts
+import { QueuedAiProvider } from "@workglow/ai";
+init_HFT_Pipeline();
+var GPU_DEVICES = new Set(["webgpu", "gpu", "metal"]);
+var HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION = 4;
+function hftIsAutomatedTestEnvironment() {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const e = process.env;
+  return e.VITEST === "true" || e.NODE_ENV === "test" || e.BUN_TEST === "1" || e.JEST_WORKER_ID !== undefined;
+}
+function hftDefaultCpuQueueConcurrency() {
+  return hftIsAutomatedTestEnvironment() ? 1 : HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION;
+}
+function resolveHftCpuQueueConcurrency(concurrency, defaultCpu) {
+  if (concurrency === undefined) {
+    return defaultCpu();
+  }
+  if (typeof concurrency === "number") {
+    return defaultCpu();
+  }
+  return concurrency.cpu ?? defaultCpu();
+}
+
+class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
+  name = HF_TRANSFORMERS_ONNX;
+  displayName = "Hugging Face Transformers (ONNX)";
+  isLocal = true;
+  supportsBrowser = true;
+  cpuStrategy;
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferHftCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return hftWorkerRunFnSpecs();
+  }
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(sessionId) {
+    deleteHftSession(sessionId);
+  }
+  async afterRegister(options) {
+    await super.afterRegister(options);
+    this.cpuStrategy = this.createQueuedStrategy(HF_TRANSFORMERS_ONNX_CPU, resolveHftCpuQueueConcurrency(options.queue?.concurrency, hftDefaultCpuQueueConcurrency), options);
+  }
+  getStrategyForModel(model) {
+    const device = model.provider_config?.device;
+    if (device && GPU_DEVICES.has(device)) {
+      return this.queuedStrategy;
+    }
+    return this.cpuStrategy;
+  }
+}
+// src/ai/registerHuggingFaceTransformers.ts
+import { registerProviderWithWorker } from "@workglow/ai/provider-utils";
+async function registerHuggingFaceTransformers(options) {
+  await registerProviderWithWorker(new HuggingFaceTransformersQueuedProvider, "HuggingFaceTransformers", options);
+}
+// src/ai/common/HFT_BackgroundRemoval.ts
+init_HFT_Pipeline();
+import { dataUriToImageValue, imageValueToBlob } from "@workglow/ai/provider-utils";
+function rawImageToBase64Png(image) {
+  const fn = image.toBase64;
+  if (typeof fn !== "function") {
+    throw new Error("HFT_BackgroundRemoval: RawImage.toBase64 unavailable in this transformers version");
+  }
+  return fn.call(image);
+}
+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)}`;
+  emit({
+    type: "finish",
+    data: {
+      image: await dataUriToImageValue(dataUri)
+    }
+  });
+};
+
+// src/ai/common/HFT_Chat.ts
+init_HFT_Pipeline();
+
+// src/ai/common/HFT_ToolCalling.ts
+init_HFT_Pipeline();
+import {
+  buildToolDescription,
+  filterValidToolCalls,
+  toTextFlatMessages
+} from "@workglow/ai/worker";
+import {
+  adaptParserResult,
+  forcedToolSelection,
+  getAvailableParsers,
+  getGenerationPrefix,
+  parseToolCalls
+} from "@workglow/ai/provider-utils";
+
+// src/ai/common/HFT_Streaming.ts
+function createStreamingTextStreamer(tokenizer, onText, textStreamer) {
+  return new textStreamer(tokenizer, {
+    skip_prompt: true,
+    decode_kwargs: { skip_special_tokens: true },
+    callback_function: onText
+  });
+}
+function createTextStreamer(tokenizer, updateProgress, textStreamer) {
+  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 });
+    }
+  });
+}
+
+// src/ai/common/HFT_ToolCalling.ts
+function getModelTextCandidates(model) {
+  return [model.model_id, model.title, model.description, model.provider_config.model_path].filter((value) => typeof value === "string" && value.length > 0).map((value) => value.toLowerCase());
+}
+function detectModelFamilyFromConfig(model) {
+  const candidates = getModelTextCandidates(model);
+  const families = getAvailableParsers();
+  for (const candidate of candidates) {
+    for (const family of families) {
+      if (candidate.includes(family)) {
+        return family;
+      }
+    }
+  }
+  return null;
+}
+function normalizeParsedToolCalls(input, toolCalls) {
+  const forcedToolName = forcedToolSelection(input);
+  return toolCalls.map((toolCall) => toolCall.name ? toolCall : {
+    ...toolCall,
+    name: forcedToolName ?? toolCall.name
+  });
+}
+function mapHFTTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+}
+function resolveHFTToolsAndMessages(input, messages) {
+  if (input.toolChoice === "none") {
+    return;
+  }
+  if (input.toolChoice === "required") {
+    const requiredInstruction = "You must call at least one tool from the provided tool list when answering.";
+    if (messages.length > 0 && messages[0].role === "system") {
+      messages[0] = { ...messages[0], content: `${messages[0].content}
+
+${requiredInstruction}` };
+    } else {
+      messages.unshift({ role: "system", content: requiredInstruction });
+    }
+    return mapHFTTools(input.tools);
+  }
+  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto") {
+    const selectedTools = input.tools?.filter((tool) => tool.name === input.toolChoice);
+    const toolsToMap = selectedTools && selectedTools.length > 0 ? selectedTools : input.tools;
+    return mapHFTTools(toolsToMap);
+  }
+  return mapHFTTools(input.tools);
+}
+function buildHFTMessages(messages, systemPrompt, prompt, toolChoice) {
+  const out = [];
+  if (systemPrompt) {
+    out.push({ role: "system", content: systemPrompt });
+  }
+  if (toolChoice === "required") {
+    out.push({
+      role: "system",
+      content: "You MUST call one of the provided tools in this turn."
+    });
+  }
+  if (!messages || messages.length === 0) {
+    out.push({ role: "user", content: extractPromptText(prompt) });
+    return out;
+  }
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      out.push({ role: "user", content: text });
+    } else if (msg.role === "assistant") {
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => {
+        const tu = b;
+        return { id: tu.id, name: tu.name, arguments: tu.input };
+      });
+      const entry = { role: "assistant", content: text };
+      if (toolCalls.length > 0)
+        entry.tool_calls = toolCalls;
+      out.push(entry);
+    } else if (msg.role === "tool") {
+      for (const b of msg.content) {
+        if (b.type !== "tool_result")
+          continue;
+        const text = b.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
+        out.push({
+          role: "tool",
+          content: text,
+          tool_call_id: b.tool_use_id
+        });
+      }
+    }
+  }
+  return out;
+}
+function extractPromptText(prompt) {
+  if (typeof prompt === "string")
+    return prompt;
+  if (!Array.isArray(prompt))
+    return String(prompt ?? "");
+  return prompt.map((item) => {
+    if (typeof item === "string")
+      return item;
+    if (item && typeof item === "object" && item.type === "text") {
+      return item.text;
+    }
+    return "";
+  }).filter((s) => s).join(`
+`);
+}
+function selectHFTTools(input) {
+  if (input.toolChoice === "none")
+    return;
+  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto" && input.toolChoice !== "required") {
+    const selected = input.tools.filter((t) => t.name === input.toolChoice);
+    return mapHFTTools(selected.length > 0 ? selected : input.tools);
+  }
+  return mapHFTTools(input.tools);
+}
+function hasToolMessages(input) {
+  return input.messages?.some((m) => m.role === "tool") ?? false;
+}
+function buildPromptAndPrefix(tokenizer, input, modelFamily) {
+  let basePrompt;
+  if (hasToolMessages(input)) {
+    const messages = buildHFTMessages(input.messages, input.systemPrompt, input.prompt, input.toolChoice);
+    const tools = selectHFTTools(input);
+    basePrompt = tokenizer.apply_chat_template(messages, {
+      tools,
+      tokenize: false,
+      add_generation_prompt: true
+    });
+  } else {
+    const messages = toTextFlatMessages(input);
+    const tools = resolveHFTToolsAndMessages(input, messages);
+    basePrompt = tokenizer.apply_chat_template(messages, {
+      tools,
+      tokenize: false,
+      add_generation_prompt: true
+    });
+  }
+  const responsePrefix = input.toolChoice === "none" || hasToolMessages(input) ? undefined : getGenerationPrefix(modelFamily, forcedToolSelection(input));
+  return {
+    prompt: responsePrefix ? `${basePrompt}${responsePrefix}` : basePrompt,
+    responsePrefix
+  };
+}
+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);
+  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 });
+  }
+  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 hfModel = generateText.model;
+    const hfTokenizer = generateText.tokenizer;
+    const cache = new DynamicCache;
+    const tokenized = hfTokenizer(prompt);
+    await hfModel.generate({
+      ...tokenized,
+      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);
+  }
+  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();
+  }
+  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) {
+    emit({ type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] });
+  }
+  emit({
+    type: "finish",
+    data: { text: cleanedText, toolCalls: validToolCalls }
+  });
+};
+
+// src/ai/common/HFT_Chat.ts
+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;
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const messages = buildHFTMessages(input.messages, input.systemPrompt, input.prompt, undefined);
+  const prompt = hfTokenizer.apply_chat_template(messages, {
+    tokenize: false,
+    add_generation_prompt: true
+  });
+  const inputs = hfTokenizer(prompt);
+  const promptLen = inputs.input_ids.dims[1];
+  const modelPath = model.provider_config.model_path;
+  let session = sessionId ? getHftSession(sessionId) : undefined;
+  let past_key_values = undefined;
+  if (session?.mode === "prefix-rewind" && session.modelPath === modelPath) {
+    const { DynamicCache } = await loadTransformersSDK();
+    past_key_values = new DynamicCache(session.baseEntries);
+  }
+  let accumulated = "";
+  let streamer;
+  if (onDelta) {
+    streamer = createStreamingTextStreamer(hfTokenizer, (text) => {
+      accumulated += text;
+      onDelta(text);
+    }, TextStreamer);
+  } else {
+    streamer = createTextStreamer(hfTokenizer, (progress, message) => emit({ type: "phase", message: message ?? "", progress }), TextStreamer);
+  }
+  const output = await hfModel.generate({
+    ...inputs,
+    max_new_tokens: input.maxTokens ?? 1024,
+    temperature: input.temperature ?? undefined,
+    streamer,
+    stopping_criteria: [stopping_criteria],
+    ...past_key_values ? { past_key_values } : {}
+  });
+  if (!onDelta) {
+    const seqLen = output.dims[1];
+    const newTokens = output.slice(0, [promptLen, seqLen], null);
+    accumulated = hfTokenizer.decode(newTokens, { skip_special_tokens: true });
+  }
+  if (sessionId) {
+    let outputCache;
+    if (past_key_values) {
+      outputCache = past_key_values;
+    } else if (output.past_key_values) {
+      outputCache = output.past_key_values;
+    }
+    if (outputCache) {
+      const baseEntries = {};
+      for (const key of Object.keys(outputCache)) {
+        baseEntries[key] = outputCache[key];
+      }
+      const newSession = {
+        mode: "prefix-rewind",
+        baseEntries,
+        baseSeqLength: outputCache.get_seq_length ? outputCache.get_seq_length() : 0,
+        modelPath
+      };
+      setHftSession(sessionId, newSession);
+    }
+  }
+  return accumulated;
+}
+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();
+async function countTokens(input, model) {
+  const { AutoTokenizer } = await loadTransformersSDK();
+  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 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, 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, emit, {}, signal, 100);
+  logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
+  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, 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, emit, {}, signal);
+    const imageArg2 = await imageValueToBlob2(input.image);
+    const result2 = await zeroShotClassifier(imageArg2, input.categories, {});
+    const results2 = Array.isArray(result2) ? result2 : [result2];
+    emit({
+      type: "finish",
+      data: {
+        categories: results2.map((r) => ({
+          label: r.label,
+          score: r.score
+        }))
+      }
+    });
+    return;
+  }
+  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];
+  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, 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, emit, {}, signal);
+  logger.debug("HFT ImageEmbedding: pipeline ready, generating embedding", {
+    model: model?.provider_config.model_path
+  });
+  if (Array.isArray(input.image)) {
+    const vectors = [];
+    for (const image of input.image) {
+      const imageArg2 = await imageValueToBlob3(image);
+      const result2 = await embedder(imageArg2);
+      vectors.push(result2.data);
+    }
+    logger.timeEnd(timerLabel, { count: vectors.length });
+    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 });
+  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, signal, emit) => {
+  const segmenter = await getPipeline(model, emit, {}, signal);
+  const imageArg = await imageValueToBlob4(input.image);
+  const result = await segmenter(imageArg, {
+    threshold: input.threshold,
+    mask_threshold: input.maskThreshold
+  });
+  const masks = Array.isArray(result) ? result : [result];
+  const processedMasks = await Promise.all(masks.map(async (mask) => ({
+    label: mask.label || "",
+    score: mask.score || 0,
+    mask: {}
+  })));
+  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, 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;
+  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, _signal, emit) => {
+  if (input.detail === "dimensions") {
+    if (!model)
+      throw new Error("Model config is required for ModelInfoTask.");
+    const pc = model.provider_config;
+    let native_dimensions = typeof pc.native_dimensions === "number" ? pc.native_dimensions : undefined;
+    const mrl = typeof pc.mrl === "boolean" ? pc.mrl : false;
+    if (native_dimensions === undefined && typeof pc.model_path === "string") {
+      try {
+        const response = await fetch(`https://huggingface.co/${pc.model_path}/resolve/${pc.revision ?? "main"}/config.json`);
+        if (response.ok) {
+          const config = await response.json();
+          if (typeof config.hidden_size === "number") {
+            native_dimensions = config.hidden_size;
+          }
+        }
+      } catch {}
+    }
+    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();
+  const timerLabel = `hft:ModelInfo:${model?.provider_config.model_path}`;
+  logger.time(timerLabel, { model: model?.provider_config.model_path });
+  const detail = input.detail;
+  const is_loaded = hasCachedPipeline(getPipelineCacheKey(model));
+  const { pipeline: pipelineType, model_path, dtype, device } = model.provider_config;
+  const cacheOptions = {
+    ...dtype ? { dtype } : {},
+    ...device ? { device } : {}
+  };
+  const cacheStatus = await ModelRegistry.is_pipeline_cached_files(pipelineType, model_path, cacheOptions);
+  logger.debug("is_pipeline_cached", {
+    input: [pipelineType, model_path, cacheOptions],
+    result: cacheStatus
+  });
+  const is_cached = is_loaded || cacheStatus.allCached;
+  let file_sizes = null;
+  if (detail === "files" && cacheStatus.files.length > 0) {
+    const sizes = {};
+    for (const { file } of cacheStatus.files) {
+      sizes[file] = 0;
+    }
+    file_sizes = sizes;
+  } else if (detail === "files_with_metadata" && cacheStatus.files.length > 0) {
+    const sizes = {};
+    await Promise.all(cacheStatus.files.map(async ({ file }) => {
+      const metadata = await ModelRegistry.get_file_metadata(model_path, file);
+      if (metadata.exists && metadata.size !== undefined) {
+        sizes[file] = metadata.size;
+      }
+    }));
+    if (Object.keys(sizes).length > 0) {
+      file_sizes = sizes;
+    }
+  }
+  let quantizations;
+  if (cacheStatus.files.length > 0) {
+    const filePaths = cacheStatus.files.map((f) => f.file);
+    const quantizations_parsed = parseOnnxQuantizations({ filePaths });
+    if (quantizations_parsed.length > 0) {
+      quantizations = quantizations_parsed;
+    }
+  }
+  logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
+  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, 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, emit, {}, signal);
+    const imageArg2 = await imageValueToBlob6(input.image);
+    const result = await zeroShotDetector(imageArg2, Array.from(input.labels), {
+      threshold: input.threshold
+    });
+    emit({
+      type: "finish",
+      data: {
+        detections: result.map((d) => ({
+          label: d.label,
+          score: d.score,
+          box: d.box
+        }))
+      }
+    });
+    return;
+  }
+  const detector = await getPipeline(model, emit, {}, signal);
+  const imageArg = await imageValueToBlob6(input.image);
+  const detections = await detector(imageArg, {
+    threshold: input.threshold
+  });
+  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";
+function buildStructuredGenerationPrompt(input) {
+  const schemaStr = JSON.stringify(input.outputSchema, null, 2);
+  return `${input.prompt}
+
+` + `You MUST respond with ONLY a valid JSON object conforming to this JSON schema:
+${schemaStr}
+
+` + `Output ONLY the JSON object, no other text.`;
+}
+function stripThinkingAndSpecialTokens(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/<\|[a-z_]+\|>/g, "").trim();
+}
+function extractJsonFromText(text) {
+  const cleaned = stripThinkingAndSpecialTokens(text);
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (match) {
+      try {
+        return JSON.parse(match[0]);
+      } catch {
+        return parsePartialJson(match[0]) ?? {};
+      }
+    }
+    return {};
+  }
+}
+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 }];
+  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
+    tokenize: false,
+    add_generation_prompt: true
+  });
+  let fullText = "";
+  let cleanedText = "";
+  let inThinkBlock = false;
+  let jsonStart = -1;
+  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 {
+          remaining = "";
+        }
+      } 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 = "";
+        }
+      }
+    }
+    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]
+  });
+  const object = extractJsonFromText(fullText);
+  emit({ type: "finish", data: { object } });
+};
+
+// src/ai/common/HFT_TextClassification.ts
+init_HFT_Pipeline();
+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, emit, {}, signal);
+    const result2 = await zeroShotClassifier(input.text, input.candidateLabels, {});
+    emit({
+      type: "finish",
+      data: {
+        categories: result2.labels.map((label, idx) => ({
+          label,
+          score: result2.scores[idx]
+        }))
+      }
+    });
+    return;
+  }
+  const TextClassification = await getPipeline(model, emit, {}, signal);
+  const result = await TextClassification(input.text, {
+    top_k: input.maxCategories || undefined
+  });
+  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, 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, 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
+  });
+  const hfVector = await generateEmbedding(input.text, {
+    pooling: model?.provider_config.pooling || "mean",
+    normalize: model?.provider_config.normalize
+  });
+  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.slice());
+    logger.timeEnd(timerLabel, { batchSize: numTexts, dimensions: vectorDim });
+    emit({ type: "finish", data: { vector: vectors } });
+    return;
+  }
+  if (hfVector.size !== embeddingDim) {
+    logger.timeEnd(timerLabel, { status: "error", reason: "dimension mismatch" });
+    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}`);
+  }
+  logger.timeEnd(timerLabel, { dimensions: hfVector.size });
+  emit({ type: "finish", data: { vector: hfVector.data } });
+};
+
+// src/ai/common/HFT_TextFillMask.ts
+init_HFT_Pipeline();
+var HFT_TextFillMask = async (input, model, signal, emit) => {
+  const unmasker = await getPipeline(model, emit, {}, signal);
+  const predictions = await unmasker(input.text);
+  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();
+var HFT_TextGeneration = async (input, model, signal, emit, _outputSchema, sessionId) => {
+  const generateText = await getPipeline(model, emit, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  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 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 }];
+  await generateText(messages, {
+    streamer,
+    do_sample: false,
+    max_new_tokens: input.maxTokens ?? 4 * 1024,
+    stopping_criteria: [stopping_criteria],
+    ...past_key_values ? { past_key_values } : {}
+  });
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/HFT_TextLanguageDetection.ts
+init_HFT_Pipeline();
+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
+  });
+  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, signal, emit) => {
+  const textNamedEntityRecognition = await getPipeline(model, emit, {}, signal);
+  const results = await textNamedEntityRecognition(input.text, {
+    ignore_labels: input.blockList
+  });
+  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, signal, emit) => {
+  const generateAnswer = await getPipeline(model, emit, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  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 pipelineResult = await generateAnswer(input.question, input.context, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  const answerText = Array.isArray(pipelineResult) ? pipelineResult[0]?.answer ?? "" : pipelineResult?.answer ?? "";
+  emit({ type: "finish", data: { text: answerText } });
+};
+
+// src/ai/common/HFT_TextReranker.ts
+init_HFT_Pipeline();
+import { KbRerankerOutputError } from "@workglow/ai";
+import { getLogger as getLogger6 } from "@workglow/util/worker";
+function isScored(v) {
+  return typeof v === "object" && v !== null && typeof v.score === "number";
+}
+function truncateShape(value) {
+  try {
+    const json = JSON.stringify(value);
+    if (typeof json !== "string")
+      return String(value);
+    return json.length > 200 ? `${json.slice(0, 200)}…` : json;
+  } catch {
+    return String(value);
+  }
+}
+function validateAndExtractRerankerScores(rawResults, modelPath) {
+  if (!Array.isArray(rawResults)) {
+    throw new KbRerankerOutputError(`HFT_TextReranker: unexpected pipeline output shape for model ${modelPath}`, truncateShape(rawResults));
+  }
+  const scores = new Array(rawResults.length);
+  for (let i = 0;i < rawResults.length; i++) {
+    const entry = rawResults[i];
+    const candidate = Array.isArray(entry) ? entry[0] : entry;
+    if (!isScored(candidate)) {
+      throw new KbRerankerOutputError(`HFT_TextReranker: unexpected pipeline output shape for model ${modelPath}`, truncateShape(entry));
+    }
+    scores[i] = candidate.score;
+  }
+  return scores;
+}
+var HFT_TextReranker = async (input, model, signal, emit) => {
+  const logger = getLogger6();
+  const modelPath = model?.provider_config.model_path;
+  const timerLabel = `hft:TextReranker:${modelPath}`;
+  logger.time(timerLabel, { docs: input.documents.length });
+  const reranker = await getPipeline(model, emit, {}, signal);
+  const pairs = input.documents.map((doc) => ({ text: input.query, text_pair: doc }));
+  const callable = reranker;
+  const rawResults = await callable(pairs, { top_k: 1 });
+  const scores = validateAndExtractRerankerScores(rawResults, modelPath);
+  const indices = scores.map((score, idx) => ({ score, idx })).sort((a, b) => b.score - a.score).map((p) => p.idx);
+  const limited = typeof input.topK === "number" ? indices.slice(0, input.topK) : indices;
+  logger.timeEnd(timerLabel, { docs: input.documents.length });
+  emit({ type: "finish", data: { scores, indices: limited } });
+};
+
+// src/ai/common/HFT_TextRewriter.ts
+init_HFT_Pipeline();
+var HFT_TextRewriter = async (input, model, signal, emit) => {
+  const generateText = await getPipeline(model, emit, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  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;
+  await generateText(promptedText, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/HFT_TextSummary.ts
+init_HFT_Pipeline();
+var HFT_TextSummary = async (input, model, signal, emit) => {
+  const generateSummary = await getPipeline(model, emit, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  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 });
+  }
+  await generateSummary(input.text, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  emit({ type: "finish", data: {} });
+};
+
+// src/ai/common/HFT_TextTranslation.ts
+init_HFT_Pipeline();
+var HFT_TextTranslation = async (input, model, signal, emit) => {
+  const translate = await getPipeline(model, emit, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  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 });
+  }
+  await translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  emit({ type: "finish", data: { target_lang: input.target_lang } });
+};
+
+// 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 HFT_TextGeneration(input, model, signal, emit, outputSchema, sessionId);
+  }
+};
+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_RERANKING, runFn: HFT_TextReranker },
+  { 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
+};
+
+// src/ai/index.ts
+var _testOnly = {
+  HFT_RUN_FN_SPECS,
+  HFT_RUN_FNS
+};
 export {
   registerHuggingFaceTransformers,
   parseOnnxQuantizations,
   createToolCallMarkupFilter,
+  _testOnly,
   QuantizationDataType,
   PipelineUseCase,
   ONNX_QUANTIZATION_SUFFIX_MAPPING,
@@ -876,4 +2127,4 @@ export {
   HF_TRANSFORMERS_ONNX
 };
 
-//# debugId=1F98AB72335DB69764756E2164756E21
+//# debugId=FC830CCDC8DBF09664756E2164756E21