@workglow/ai-provider 0.0.121 → 0.0.123

package/dist/{index-j4g81r4k.js → provider-hf-transformers/runtime.js}

@@ -1,26 +1,58 @@
-import {
-  HTF_CACHE_NAME
-} from "./index-zqq3kw0n.js";
-import {
-  __require
-} from "./index-6j5pq722.js";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
-// src/hf-transformers/common/HFT_JobRunFns.ts
-import { buildToolDescription, filterValidToolCalls, toTextFlatMessages } from "@workglow/ai";
-import { getLogger, parsePartialJson } from "@workglow/util";
-var _transformersSdk;
+// src/provider-hf-transformers/common/HFT_Pipeline.ts
+var exports_HFT_Pipeline = {};
+__export(exports_HFT_Pipeline, {
+  setHftCacheDir: () => setHftCacheDir,
+  removeCachedPipeline: () => removeCachedPipeline,
+  loadTransformersSDK: () => loadTransformersSDK,
+  hasCachedPipeline: () => hasCachedPipeline,
+  getPipelineCacheKey: () => getPipelineCacheKey,
+  getPipeline: () => getPipeline,
+  clearPipelineCache: () => clearPipelineCache
+});
+import { getLogger } from "@workglow/util/worker";
+function setHftCacheDir(dir) {
+  _cacheDir = dir;
+  if (_transformersSdk) {
+    _transformersSdk.env.cacheDir = dir;
+  }
+}
 async function loadTransformersSDK() {
   if (!_transformersSdk) {
     try {
       _transformersSdk = await import("@huggingface/transformers");
       _transformersSdk.env.fetch = abortableFetch;
+      if (_cacheDir) {
+        _transformersSdk.env.cacheDir = _cacheDir;
+      }
     } catch {
       throw new Error("@huggingface/transformers is required for HuggingFace Transformers tasks. Install it with: bun add @huggingface/transformers");
     }
   }
   return _transformersSdk;
 }
-var modelAbortControllers = new Map;
 function abortableFetch(url, options) {
   let signal;
   try {
@@ -34,17 +66,24 @@ function abortableFetch(url, options) {
   } catch {}
   return fetch(url, { ...options, ...signal ? { signal } : {} });
 }
-var pipelines = new Map;
-var pipelineLoadPromises = new Map;
 function clearPipelineCache() {
   pipelines.clear();
 }
+function hasCachedPipeline(cacheKey) {
+  return pipelines.has(cacheKey);
+}
+function removeCachedPipeline(cacheKey) {
+  return pipelines.delete(cacheKey);
+}
+function isBrowserEnv() {
+  return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+}
 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 = {}, signal, progressScaleMax = 10) => {
+async function getPipeline(model, onProgress, options = {}, signal, progressScaleMax = 10) {
   const cacheKey = getPipelineCacheKey(model);
   if (pipelines.has(cacheKey)) {
     getLogger().debug("HFT pipeline cache hit", { cacheKey });
@@ -62,13 +101,23 @@ var getPipeline = async (model, onProgress, options = {}, signal, progressScaleM
   });
   pipelineLoadPromises.set(cacheKey, loadPromise);
   return loadPromise;
-};
-var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKey, signal) => {
+}
+var _transformersSdk, _cacheDir, modelAbortControllers, pipelines, pipelineLoadPromises, doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKey, signal) => {
   let lastProgressTime = 0;
   let pendingProgress = null;
   let throttleTimer = null;
   const THROTTLE_MS = 160;
-  const sendProgress = (progress, file, fileProgress) => {
+  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 now = Date.now();
     const timeSinceLastEvent = now - lastProgressTime;
     const isFirst = lastProgressTime === 0;
@@ -79,21 +128,19 @@ var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKe
         throttleTimer = null;
       }
       pendingProgress = null;
-      onProgress(Math.round(progress), "Downloading model", { file, progress: fileProgress });
+      onProgress(Math.round(progress), "Downloading model", buildProgressDetails(file, fileProgress, filesMap));
       lastProgressTime = now;
       return;
     }
     if (timeSinceLastEvent < THROTTLE_MS) {
-      pendingProgress = { progress, file, fileProgress };
+      pendingProgress = { progress, file, fileProgress, filesMap };
       if (!throttleTimer) {
         const timeRemaining = Math.max(1, THROTTLE_MS - timeSinceLastEvent);
         throttleTimer = setTimeout(() => {
           throttleTimer = null;
           if (pendingProgress) {
-            onProgress(Math.round(pendingProgress.progress), "Downloading model", {
-              file: pendingProgress.file,
-              progress: pendingProgress.fileProgress
-            });
+            const p = pendingProgress;
+            onProgress(Math.round(p.progress), "Downloading model", buildProgressDetails(p.file, p.fileProgress, p.filesMap));
             lastProgressTime = Date.now();
             pendingProgress = null;
           }
@@ -101,7 +148,7 @@ var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKe
       }
       return;
     }
-    onProgress(Math.round(progress), "Downloading model", { file, progress: fileProgress });
+    onProgress(Math.round(progress), "Downloading model", buildProgressDetails(file, fileProgress, filesMap));
     lastProgressTime = now;
     pendingProgress = null;
   };
@@ -141,13 +188,19 @@ var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKe
           }
         }
       }
-      sendProgress(scaledProgress, activeFile, activeFileProgress);
+      sendProgress(scaledProgress, activeFile, activeFileProgress, files);
     }
   };
+  let device = model.provider_config.device;
+  if (!isBrowserEnv()) {
+    if (device === "wasm" || device === "webgpu") {
+      device = undefined;
+    }
+  }
   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 } : {},
+    ...device ? { device } : {},
     ...options,
     progress_callback: progressCallback
   };
@@ -168,10 +221,7 @@ var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKe
     }
     const finalPending = pendingProgress;
     if (finalPending) {
-      onProgress(Math.round(finalPending.progress), "Downloading model", {
-        file: finalPending.file,
-        progress: finalPending.fileProgress
-      });
+      onProgress(Math.round(finalPending.progress), "Downloading model", buildProgressDetails(finalPending.file, finalPending.fileProgress, finalPending.filesMap));
       pendingProgress = null;
     }
     if (abortSignal?.aborted) {
@@ -191,234 +241,1066 @@ var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKe
     modelAbortControllers.delete(modelPath);
   }
 };
-var HFT_Download = async (input, model, onProgress, signal) => {
-  const logger = getLogger();
-  const timerLabel = `hft:Download:${model?.provider_config.model_path}`;
-  logger.time(timerLabel, { model: model?.provider_config.model_path });
-  await getPipeline(model, onProgress, {}, signal, 100);
-  logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
-  return {
-    model: input.model
-  };
+var init_HFT_Pipeline = __esm(() => {
+  modelAbortControllers = new Map;
+  pipelines = new Map;
+  pipelineLoadPromises = new Map;
+});
+
+// src/provider-hf-transformers/common/HFT_Constants.ts
+var HF_TRANSFORMERS_ONNX = "HF_TRANSFORMERS_ONNX";
+var HTF_CACHE_NAME = "transformers-cache";
+var QuantizationDataType = {
+  auto: "auto",
+  fp32: "fp32",
+  fp16: "fp16",
+  q8: "q8",
+  int8: "int8",
+  uint8: "uint8",
+  q4: "q4",
+  bnb4: "bnb4",
+  q4f16: "q4f16"
 };
-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 TextPipelineUseCase = {
+  "fill-mask": "fill-mask",
+  "token-classification": "token-classification",
+  "text-generation": "text-generation",
+  "text2text-generation": "text2text-generation",
+  "text-classification": "text-classification",
+  summarization: "summarization",
+  translation: "translation",
+  "feature-extraction": "feature-extraction",
+  "zero-shot-classification": "zero-shot-classification",
+  "question-answering": "question-answering"
 };
-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++;
+var VisionPipelineUseCase = {
+  "background-removal": "background-removal",
+  "image-segmentation": "image-segmentation",
+  "depth-estimation": "depth-estimation",
+  "image-classification": "image-classification",
+  "image-to-image": "image-to-image",
+  "image-to-text": "image-to-text",
+  "object-detection": "object-detection",
+  "image-feature-extraction": "image-feature-extraction"
+};
+var AudioPipelineUseCase = {
+  "audio-classification": "audio-classification",
+  "automatic-speech-recognition": "automatic-speech-recognition",
+  "text-to-speech": "text-to-speech"
+};
+var MultimodalPipelineUseCase = {
+  "document-question-answering": "document-question-answering",
+  "image-to-text": "image-to-text",
+  "zero-shot-audio-classification": "zero-shot-audio-classification",
+  "zero-shot-image-classification": "zero-shot-image-classification",
+  "zero-shot-object-detection": "zero-shot-object-detection"
+};
+var PipelineUseCase = {
+  ...TextPipelineUseCase,
+  ...VisionPipelineUseCase,
+  ...AudioPipelineUseCase,
+  ...MultimodalPipelineUseCase
+};
+// src/provider-hf-transformers/common/HFT_ModelSchema.ts
+import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai/worker";
+var HfTransformersOnnxModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: HF_TRANSFORMERS_ONNX,
+      description: "Discriminator: ONNX runtime backend."
+    },
+    provider_config: {
+      type: "object",
+      description: "ONNX runtime-specific options.",
+      properties: {
+        pipeline: {
+          type: "string",
+          enum: Object.values(PipelineUseCase),
+          description: "Pipeline type for the ONNX model.",
+          default: "text-generation"
+        },
+        model_path: {
+          type: "string",
+          description: "Filesystem path or URI for the ONNX model."
+        },
+        dtype: {
+          type: "string",
+          enum: Object.values(QuantizationDataType),
+          description: "Data type for the ONNX model.",
+          default: "auto"
+        },
+        device: {
+          type: "string",
+          enum: ["cpu", "gpu", "webgpu", "wasm", "metal"],
+          description: "High-level device selection.",
+          default: "webgpu"
+        },
+        execution_providers: {
+          type: "array",
+          items: { type: "string" },
+          description: "Raw ONNX Runtime execution provider identifiers.",
+          "x-ui-hidden": true
+        },
+        intra_op_num_threads: {
+          type: "integer",
+          minimum: 1
+        },
+        inter_op_num_threads: {
+          type: "integer",
+          minimum: 1
+        },
+        use_external_data_format: {
+          type: "boolean",
+          description: "Whether the model uses external data format."
+        },
+        native_dimensions: {
+          type: "integer",
+          description: "The native dimensions of the model."
+        },
+        pooling: {
+          type: "string",
+          enum: ["mean", "last_token", "cls"],
+          description: "The pooling strategy to use for the model.",
+          default: "mean"
+        },
+        normalize: {
+          type: "boolean",
+          description: "Whether the model uses normalization.",
+          default: true
+        },
+        language_style: {
+          type: "string",
+          description: "The language style of the model."
+        },
+        mrl: {
+          type: "boolean",
+          description: "Whether the model uses matryoshka.",
+          default: false
         }
+      },
+      required: ["model_path", "pipeline"],
+      additionalProperties: false,
+      if: {
+        properties: {
+          pipeline: {
+            const: "feature-extraction"
+          }
+        }
+      },
+      then: {
+        required: ["native_dimensions"]
       }
-    } catch (error) {
-      console.error(`Failed to delete cache entry: ${request.url}`, error);
     }
-  }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
 };
-var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
-  const logger = getLogger();
-  const uuid = crypto.randomUUID();
-  const timerLabel = `hft:TextEmbedding:${model?.provider_config.model_path}:${uuid}`;
-  logger.time(timerLabel, { model: model?.provider_config.model_path });
-  const generateEmbedding = await getPipeline(model, onProgress, {}, signal);
-  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 });
-    return { vector: vectors };
-  }
-  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 });
-  return { vector: hfVector.data };
+var HfTransformersOnnxModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...HfTransformersOnnxModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...HfTransformersOnnxModelSchema.required],
+  additionalProperties: false
 };
-var HFT_TextClassification = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
-  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");
+var HfTransformersOnnxModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...HfTransformersOnnxModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...HfTransformersOnnxModelSchema.required],
+  additionalProperties: false
+};
+// src/provider-hf-transformers/common/HFT_OnnxDtypes.ts
+var ONNX_QUANTIZATION_SUFFIX_MAPPING = {
+  fp32: "",
+  fp16: "_fp16",
+  int8: "_int8",
+  uint8: "_uint8",
+  q8: "_quantized",
+  q4: "_q4",
+  q4f16: "_q4f16",
+  bnb4: "_bnb4"
+};
+var SUFFIXES_LONGEST_FIRST = Object.entries(ONNX_QUANTIZATION_SUFFIX_MAPPING).filter(([, suffix]) => suffix !== "").sort((a, b) => b[1].length - a[1].length);
+function parseOnnxQuantizations(params) {
+  const subfolder = params.subfolder ?? "onnx";
+  const prefix = subfolder + "/";
+  const stems = [];
+  for (const fp of params.filePaths) {
+    if (!fp.startsWith(prefix))
+      continue;
+    if (!fp.endsWith(".onnx"))
+      continue;
+    if (fp.endsWith(".onnx_data"))
+      continue;
+    stems.push(fp.slice(prefix.length, -".onnx".length));
+  }
+  if (stems.length === 0)
+    return [];
+  const parsed = [];
+  for (const stem of stems) {
+    let matched = false;
+    for (const [dtype, suffix] of SUFFIXES_LONGEST_FIRST) {
+      if (stem.endsWith(suffix)) {
+        parsed.push({ baseName: stem.slice(0, -suffix.length), dtype });
+        matched = true;
+        break;
+      }
     }
-    const zeroShotClassifier = await getPipeline(model, onProgress, {}, signal);
-    const result2 = await zeroShotClassifier(input.text, input.candidateLabels, {});
-    if (isArrayInput) {
-      const results = Array.isArray(result2) && Array.isArray(result2[0]?.labels) ? result2 : [result2];
-      return {
-        categories: results.map((r) => r.labels.map((label, idx) => ({
-          label,
-          score: r.scores[idx]
-        })))
-      };
+    if (!matched) {
+      parsed.push({ baseName: stem, dtype: "fp32" });
     }
-    return {
-      categories: result2.labels.map((label, idx) => ({
-        label,
-        score: result2.scores[idx]
-      }))
-    };
-  }
-  const TextClassification = await getPipeline(model, onProgress, {}, signal);
-  const result = await TextClassification(input.text, {
-    top_k: input.maxCategories || undefined
-  });
-  if (isArrayInput) {
-    return {
-      categories: result.map((perInput) => {
-        const items = Array.isArray(perInput) ? perInput : [perInput];
-        return items.map((category) => ({
-          label: category.label,
-          score: category.score
-        }));
-      })
-    };
-  }
-  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 isArrayInput = Array.isArray(input.text);
-  const TextClassification = await getPipeline(model, onProgress, {}, signal);
-  const result = await TextClassification(input.text, {
-    top_k: input.maxLanguages || undefined
-  });
-  if (isArrayInput) {
-    return {
-      languages: result.map((perInput) => {
-        const items = Array.isArray(perInput) ? perInput : [perInput];
-        return items.map((category) => ({
-          language: category.label,
-          score: category.score
-        }));
-      })
-    };
   }
-  if (Array.isArray(result[0])) {
-    return {
-      languages: result[0].map((category) => ({
-        language: category.label,
-        score: category.score
-      }))
-    };
+  const allBaseNames = new Set(parsed.map((p) => p.baseName));
+  const byDtype = new Map;
+  for (const { baseName, dtype } of parsed) {
+    let set = byDtype.get(dtype);
+    if (!set) {
+      set = new Set;
+      byDtype.set(dtype, set);
+    }
+    set.add(baseName);
   }
-  return {
-    languages: result.map((category) => ({
-      language: category.label,
-      score: category.score
-    }))
-  };
-};
-var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
-  const textNamedEntityRecognition = await getPipeline(model, onProgress, {}, signal);
-  const results = await textNamedEntityRecognition(input.text, {
-    ignore_labels: input.blockList
+  const allDtypes = Object.keys(ONNX_QUANTIZATION_SUFFIX_MAPPING);
+  return allDtypes.filter((dtype) => {
+    const set = byDtype.get(dtype);
+    return set !== undefined && set.size === allBaseNames.size;
   });
-  if (isArrayInput) {
-    return {
-      entities: results.map((perInput) => {
-        const items = Array.isArray(perInput) ? perInput : [perInput];
-        return items.map((entity) => ({
-          entity: entity.entity,
-          score: entity.score,
-          word: entity.word
-        }));
-      })
-    };
-  }
-  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 isArrayInput = Array.isArray(input.text);
-  const unmasker = await getPipeline(model, onProgress, {}, signal);
-  const results = await unmasker(input.text);
-  if (isArrayInput) {
-    return {
-      predictions: results.map((perInput) => {
-        const items = Array.isArray(perInput) ? perInput : [perInput];
-        return items.map((prediction) => ({
-          entity: prediction.token_str,
-          score: prediction.score,
-          sequence: prediction.sequence
-        }));
-      })
-    };
+}
+// src/provider-hf-transformers/common/HFT_ToolMarkup.ts
+function parseToolCallsFromText(responseText) {
+  const toolCalls = [];
+  let callIndex = 0;
+  let cleanedText = responseText;
+  const toolCallTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+  let tagMatch;
+  while ((tagMatch = toolCallTagRegex.exec(responseText)) !== null) {
+    try {
+      const parsed = JSON.parse(tagMatch[1].trim());
+      const id = `call_${callIndex++}`;
+      toolCalls.push({
+        id,
+        name: parsed.name ?? parsed.function?.name ?? "",
+        input: parsed.arguments ?? parsed.function?.arguments ?? parsed.parameters ?? {}
+      });
+    } catch {}
   }
-  let predictions = [];
-  if (!Array.isArray(results)) {
-    predictions = [results];
-  } else {
-    predictions = results;
+  if (toolCalls.length > 0) {
+    cleanedText = responseText.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "").trim();
+    return { text: cleanedText, toolCalls };
   }
-  return {
+  const jsonCandidates = [];
+  (function collectBalancedJsonBlocks(source) {
+    const length = source.length;
+    let i = 0;
+    while (i < length) {
+      if (source[i] !== "{") {
+        i++;
+        continue;
+      }
+      let depth = 1;
+      let j = i + 1;
+      let inString = false;
+      let escape = false;
+      while (j < length && depth > 0) {
+        const ch = source[j];
+        if (inString) {
+          if (escape) {
+            escape = false;
+          } else if (ch === "\\") {
+            escape = true;
+          } else if (ch === '"') {
+            inString = false;
+          }
+        } else {
+          if (ch === '"') {
+            inString = true;
+          } else if (ch === "{") {
+            depth++;
+          } else if (ch === "}") {
+            depth--;
+          }
+        }
+        j++;
+      }
+      if (depth === 0) {
+        jsonCandidates.push({ text: source.slice(i, j), start: i, end: j });
+        i = j;
+      } else {
+        break;
+      }
+    }
+  })(responseText);
+  const matchedRanges = [];
+  for (const candidate of jsonCandidates) {
+    try {
+      const parsed = JSON.parse(candidate.text);
+      if (parsed.name && (parsed.arguments !== undefined || parsed.parameters !== undefined)) {
+        const id = `call_${callIndex++}`;
+        toolCalls.push({
+          id,
+          name: parsed.name,
+          input: parsed.arguments ?? parsed.parameters ?? {}
+        });
+        matchedRanges.push({ start: candidate.start, end: candidate.end });
+      } else if (parsed.function?.name) {
+        let functionArgs = parsed.function.arguments ?? {};
+        if (typeof functionArgs === "string") {
+          try {
+            functionArgs = JSON.parse(functionArgs);
+          } catch (innerError) {
+            console.warn("Failed to parse tool call function.arguments as JSON", innerError);
+            functionArgs = {};
+          }
+        }
+        const id = `call_${callIndex++}`;
+        toolCalls.push({
+          id,
+          name: parsed.function.name,
+          input: functionArgs ?? {}
+        });
+        matchedRanges.push({ start: candidate.start, end: candidate.end });
+      }
+    } catch {}
+  }
+  if (toolCalls.length > 0) {
+    let result = "";
+    let lastIndex = 0;
+    for (const range of matchedRanges) {
+      result += responseText.slice(lastIndex, range.start);
+      lastIndex = range.end;
+    }
+    result += responseText.slice(lastIndex);
+    cleanedText = result.trim();
+  }
+  return { text: cleanedText, toolCalls };
+}
+function createToolCallMarkupFilter(emit) {
+  const OPEN_TAG = "<tool_call>";
+  const CLOSE_TAG = "</tool_call>";
+  let state = "text";
+  let pending = "";
+  function feed(token) {
+    if (state === "tag") {
+      pending += token;
+      const closeIdx = pending.indexOf(CLOSE_TAG);
+      if (closeIdx !== -1) {
+        const afterClose = pending.slice(closeIdx + CLOSE_TAG.length);
+        pending = "";
+        state = "text";
+        if (afterClose.length > 0) {
+          feed(afterClose);
+        }
+      }
+      return;
+    }
+    const combined = pending + token;
+    const openIdx = combined.indexOf(OPEN_TAG);
+    if (openIdx !== -1) {
+      const before = combined.slice(0, openIdx);
+      if (before.length > 0) {
+        emit(before);
+      }
+      pending = "";
+      state = "tag";
+      const afterOpen = combined.slice(openIdx + OPEN_TAG.length);
+      if (afterOpen.length > 0) {
+        feed(afterOpen);
+      }
+      return;
+    }
+    let prefixLen = 0;
+    for (let len = Math.min(combined.length, OPEN_TAG.length - 1);len >= 1; len--) {
+      if (combined.endsWith(OPEN_TAG.slice(0, len))) {
+        prefixLen = len;
+        break;
+      }
+    }
+    if (prefixLen > 0) {
+      const safe = combined.slice(0, combined.length - prefixLen);
+      if (safe.length > 0) {
+        emit(safe);
+      }
+      pending = combined.slice(combined.length - prefixLen);
+    } else {
+      if (combined.length > 0) {
+        emit(combined);
+      }
+      pending = "";
+    }
+  }
+  function flush() {
+    if (pending.length > 0 && state === "text") {
+      emit(pending);
+      pending = "";
+    }
+    pending = "";
+    state = "text";
+  }
+  return { feed, flush };
+}
+// src/provider-hf-transformers/common/HFT_InlineLifecycle.ts
+async function clearHftInlinePipelineCache() {
+  const { clearPipelineCache: clearPipelineCache2 } = await Promise.resolve().then(() => (init_HFT_Pipeline(), exports_HFT_Pipeline));
+  clearPipelineCache2();
+}
+
+// src/common/PipelineTaskMapping.ts
+var TASK_TO_PIPELINES = {
+  TextEmbeddingTask: ["feature-extraction"],
+  TextGenerationTask: ["text-generation"],
+  TextSummaryTask: ["sentence-similarity", "summarization"],
+  TextTranslationTask: ["translation"],
+  TextClassificationTask: ["text-classification", "zero-shot-classification"],
+  TextQuestionAnswerTask: ["question-answering"],
+  TextFillMaskTask: ["fill-mask"],
+  TextLanguageDetectionTask: ["text-classification"],
+  TextNamedEntityRecognitionTask: ["token-classification"],
+  TokenClassificationTask: ["token-classification"],
+  ImageClassificationTask: ["image-classification", "zero-shot-image-classification"],
+  ImageEmbeddingTask: ["image-feature-extraction"],
+  ImageSegmentationTask: ["image-segmentation"],
+  ImageToImageTask: ["image-to-image"],
+  ImageToTextTask: ["image-to-text"],
+  ObjectDetectionTask: ["object-detection", "zero-shot-object-detection"],
+  DepthEstimationTask: ["depth-estimation"],
+  AudioClassificationTask: ["audio-classification"],
+  SpeechRecognitionTask: ["automatic-speech-recognition"]
+};
+function pipelineToTaskTypes(pipeline) {
+  return Object.entries(TASK_TO_PIPELINES).filter(([, pipelines2]) => pipelines2.includes(pipeline)).map(([task]) => task);
+}
+
+// src/common/HfModelSearch.ts
+var HF_API_BASE = "https://huggingface.co/api";
+function formatDownloads(n) {
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}k`;
+  return String(n);
+}
+function mapHfProviderConfig(entry, provider) {
+  switch (provider) {
+    case "HF_TRANSFORMERS_ONNX":
+      return {
+        model_path: entry.id,
+        ...entry.pipeline_tag ? { pipeline: entry.pipeline_tag } : {}
+      };
+    case "LOCAL_LLAMACPP":
+      return { model_path: entry.id };
+    default:
+      return { model_name: entry.id };
+  }
+}
+function mapHfModelResult(entry, provider) {
+  const badges = [entry.pipeline_tag, entry.library_name].filter(Boolean).join(" | ");
+  return {
+    id: entry.id,
+    label: `${entry.id}${badges ? `  ${badges}` : ""}`,
+    description: `${formatDownloads(entry.downloads)} downloads`,
+    record: {
+      model_id: entry.id,
+      provider,
+      title: entry.id.split("/").pop() ?? entry.id,
+      description: [entry.pipeline_tag, `${formatDownloads(entry.downloads)} downloads`].filter(Boolean).join(" — "),
+      tasks: entry.pipeline_tag ? pipelineToTaskTypes(entry.pipeline_tag) : [],
+      provider_config: mapHfProviderConfig(entry, provider),
+      metadata: {}
+    },
+    raw: entry
+  };
+}
+async function searchHfModels(query, extraParams, expandFields, signal) {
+  const params = new URLSearchParams({
+    search: query,
+    limit: "500",
+    sort: "downloads",
+    direction: "-1",
+    ...extraParams
+  });
+  params.append("expand[]", "pipeline_tag");
+  if (expandFields) {
+    for (const field of expandFields) {
+      params.append("expand[]", field);
+    }
+  }
+  const res = await fetch(`${HF_API_BASE}/models?${params}`, { signal });
+  if (!res.ok)
+    throw new Error(`HuggingFace API returned ${res.status}`);
+  return res.json();
+}
+
+// src/provider-hf-transformers/common/HFT_ModelSearch.ts
+var HFT_ModelSearch = async (input, _model, _onProgress, signal) => {
+  const entries = await searchHfModels(input.query, { filter: "onnx" }, ["siblings"], signal);
+  const results = entries.map((entry) => {
+    const item = mapHfModelResult(entry, HF_TRANSFORMERS_ONNX);
+    if (entry.siblings && entry.siblings.length > 0) {
+      const filePaths = entry.siblings.map((s) => s.rfilename);
+      const quantizations = parseOnnxQuantizations({ filePaths });
+      if (quantizations.length > 0) {
+        const record = item.record;
+        const providerConfig = record.provider_config ?? {};
+        providerConfig.quantizations = quantizations;
+        record.provider_config = providerConfig;
+      }
+    }
+    const raw = item.raw;
+    delete raw.siblings;
+    return item;
+  });
+  return { results };
+};
+
+// src/provider-hf-transformers/common/HFT_ImageHelpers.ts
+function imageToBase64(image) {
+  return image.toBase64?.() || "";
+}
+
+// src/provider-hf-transformers/common/HFT_BackgroundRemoval.ts
+init_HFT_Pipeline();
+var HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
+  const remover = await getPipeline(model, onProgress, {}, signal);
+  const result = await remover(input.image);
+  const resultImage = Array.isArray(result) ? result[0] : result;
+  return {
+    image: imageToBase64(resultImage)
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_CountTokens.ts
+init_HFT_Pipeline();
+var HFT_CountTokens = async (input, model, onProgress, _signal) => {
+  const isArrayInput = Array.isArray(input.text);
+  const { AutoTokenizer } = await loadTransformersSDK();
+  const tokenizer = await AutoTokenizer.from_pretrained(model.provider_config.model_path, {
+    progress_callback: (progress) => onProgress(progress?.progress ?? 0)
+  });
+  if (isArrayInput) {
+    const texts = input.text;
+    const counts = texts.map((t) => tokenizer.encode(t).length);
+    return { count: counts };
+  }
+  const tokenIds = tokenizer.encode(input.text);
+  return { count: tokenIds.length };
+};
+var HFT_CountTokens_Reactive = async (input, _output, model) => {
+  return HFT_CountTokens(input, model, () => {}, new AbortController().signal);
+};
+
+// src/provider-hf-transformers/common/HFT_Download.ts
+init_HFT_Pipeline();
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+var HFT_Download = async (input, model, onProgress, signal) => {
+  const logger = getLogger2();
+  const timerLabel = `hft:Download:${model?.provider_config.model_path}`;
+  logger.time(timerLabel, { model: model?.provider_config.model_path });
+  await getPipeline(model, onProgress, {}, signal, 100);
+  logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
+  return {
+    model: input.model
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_ImageClassification.ts
+init_HFT_Pipeline();
+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, {}, 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, {}, signal);
+  const result = await classifier(input.image, {
+    top_k: input.maxCategories
+  });
+  const results = Array.isArray(result) ? result : [result];
+  return {
+    categories: results.map((r) => ({
+      label: r.label,
+      score: r.score
+    }))
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_ImageEmbedding.ts
+init_HFT_Pipeline();
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+var HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
+  const logger = getLogger3();
+  const timerLabel = `hft:ImageEmbedding:${model?.provider_config.model_path}`;
+  logger.time(timerLabel, { model: model?.provider_config.model_path });
+  const embedder = await getPipeline(model, onProgress, {}, signal);
+  logger.debug("HFT ImageEmbedding: pipeline ready, generating embedding", {
+    model: model?.provider_config.model_path
+  });
+  const result = await embedder(input.image);
+  logger.timeEnd(timerLabel, { dimensions: result?.data?.length });
+  return {
+    vector: result.data
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_ImageSegmentation.ts
+init_HFT_Pipeline();
+var HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
+  const segmenter = await getPipeline(model, onProgress, {}, signal);
+  const result = await segmenter(input.image, {
+    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: {}
+  })));
+  return {
+    masks: processedMasks
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_ImageToText.ts
+init_HFT_Pipeline();
+var HFT_ImageToText = async (input, model, onProgress, signal) => {
+  const captioner = await getPipeline(model, onProgress, {}, signal);
+  const result = await captioner(input.image, {
+    max_new_tokens: input.maxTokens
+  });
+  const text = Array.isArray(result) ? result[0]?.generated_text : result?.generated_text;
+  return {
+    text: text || ""
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_ModelInfo.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+init_HFT_Pipeline();
+var HFT_ModelInfo = async (input, model) => {
+  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 } = model.provider_config;
+  const cacheStatus = await ModelRegistry.is_pipeline_cached_files(pipelineType, model_path, {
+    ...dtype ? { dtype } : {}
+  });
+  logger.debug("is_pipeline_cached", {
+    input: [
+      pipelineType,
+      model_path,
+      {
+        ...dtype ? { dtype } : {}
+      }
+    ],
+    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 });
+  return {
+    model: input.model,
+    is_local: true,
+    is_remote: false,
+    supports_browser: true,
+    supports_node: true,
+    is_cached,
+    is_loaded,
+    file_sizes,
+    ...quantizations ? { quantizations } : {}
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_ObjectDetection.ts
+init_HFT_Pipeline();
+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, {}, 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, {}, signal);
+  const result = await detector(input.image, {
+    threshold: input.threshold
+  });
+  const detections = Array.isArray(result) ? result : [result];
+  return {
+    detections: detections.map((d) => ({
+      label: d.label,
+      score: d.score,
+      box: d.box
+    }))
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_StructuredGeneration.ts
+init_HFT_Pipeline();
+import { parsePartialJson } from "@workglow/util/worker";
+
+// src/provider-hf-transformers/common/HFT_Streaming.ts
+function createStreamEventQueue() {
+  const buffer = [];
+  let resolve = null;
+  let finished = false;
+  let err = null;
+  const push = (event) => {
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: event, done: false });
+    } else {
+      buffer.push(event);
+    }
+  };
+  const done = () => {
+    finished = true;
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: undefined, done: true });
+    }
+  };
+  const error = (e) => {
+    err = e;
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: undefined, done: true });
+    }
+  };
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (err)
+            return Promise.reject(err);
+          if (buffer.length > 0) {
+            return Promise.resolve({ value: buffer.shift(), done: false });
+          }
+          if (finished) {
+            return Promise.resolve({ value: undefined, done: true });
+          }
+          return new Promise((r) => {
+            resolve = r;
+          });
+        }
+      };
+    }
+  };
+  return { push, done, error, iterable };
+}
+function createStreamingTextStreamer(tokenizer, queue, textStreamer) {
+  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 });
+    }
+  });
+}
+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/provider-hf-transformers/common/HFT_TextOutput.ts
+function extractGeneratedText(generatedText) {
+  if (generatedText == null)
+    return "";
+  if (typeof generatedText === "string")
+    return generatedText;
+  const lastMessage = generatedText[generatedText.length - 1];
+  if (!lastMessage)
+    return "";
+  const content = lastMessage.content;
+  if (typeof content === "string")
+    return content;
+  for (const part of content) {
+    if (part.type === "text" && "text" in part) {
+      return part.text;
+    }
+  }
+  return "";
+}
+
+// src/provider-hf-transformers/common/HFT_StructuredGeneration.ts
+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 extractJsonFromText(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const match = text.match(/\{[\s\S]*\}/);
+    if (match) {
+      try {
+        return JSON.parse(match[0]);
+      } catch {
+        return parsePartialJson(match[0]) ?? {};
+      }
+    }
+    return {};
+  }
+}
+var HFT_StructuredGeneration = async (input, model, onProgress, signal) => {
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const prompt = buildStructuredGenerationPrompt(input);
+  const messages = [{ role: "user", content: prompt }];
+  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
+    tokenize: false,
+    add_generation_prompt: true
+  });
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  let results = await generateText(formattedPrompt, {
+    max_new_tokens: input.maxTokens ?? 1024,
+    temperature: input.temperature ?? undefined,
+    return_full_text: false,
+    streamer
+  });
+  if (!Array.isArray(results)) {
+    results = [results];
+  }
+  const responseText = extractGeneratedText(results[0]?.generated_text).trim();
+  const object = extractJsonFromText(responseText);
+  return { object };
+};
+var HFT_StructuredGeneration_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const prompt = buildStructuredGenerationPrompt(input);
+  const messages = [{ role: "user", content: prompt }];
+  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
+    tokenize: false,
+    add_generation_prompt: true
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  let fullText = "";
+  const originalPush = queue.push;
+  queue.push = (event) => {
+    if (event.type === "text-delta" && "textDelta" in event) {
+      fullText += event.textDelta;
+      const match = fullText.match(/\{[\s\S]*/);
+      if (match) {
+        const partial = parsePartialJson(match[0]);
+        if (partial !== undefined) {
+          originalPush({
+            type: "object-delta",
+            port: "object",
+            objectDelta: partial
+          });
+          return;
+        }
+      }
+    }
+    originalPush(event);
+  };
+  const pipelinePromise = generateText(formattedPrompt, {
+    max_new_tokens: input.maxTokens ?? 1024,
+    temperature: input.temperature ?? undefined,
+    return_full_text: false,
+    streamer
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  const object = extractJsonFromText(fullText);
+  yield { type: "finish", data: { object } };
+};
+
+// src/provider-hf-transformers/common/HFT_TextClassification.ts
+init_HFT_Pipeline();
+var HFT_TextClassification = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
+  if (model?.provider_config?.pipeline === "zero-shot-classification") {
+    if (!input.candidateLabels || !Array.isArray(input.candidateLabels) || input.candidateLabels.length === 0) {
+      throw new Error("Zero-shot text classification requires candidate labels");
+    }
+    const zeroShotClassifier = await getPipeline(model, onProgress, {}, signal);
+    const result2 = await zeroShotClassifier(input.text, input.candidateLabels, {});
+    if (isArrayInput) {
+      const results = Array.isArray(result2) && Array.isArray(result2[0]?.labels) ? result2 : [result2];
+      return {
+        categories: results.map((r) => r.labels.map((label, idx) => ({
+          label,
+          score: r.scores[idx]
+        })))
+      };
+    }
+    return {
+      categories: result2.labels.map((label, idx) => ({
+        label,
+        score: result2.scores[idx]
+      }))
+    };
+  }
+  const TextClassification = await getPipeline(model, onProgress, {}, signal);
+  const result = await TextClassification(input.text, {
+    top_k: input.maxCategories || undefined
+  });
+  if (isArrayInput) {
+    return {
+      categories: result.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((category) => ({
+          label: category.label,
+          score: category.score
+        }));
+      })
+    };
+  }
+  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
+    }))
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_TextEmbedding.ts
+init_HFT_Pipeline();
+import { getLogger as getLogger5 } from "@workglow/util/worker";
+var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
+  const logger = getLogger5();
+  const uuid = crypto.randomUUID();
+  const timerLabel = `hft:TextEmbedding:${model?.provider_config.model_path}:${uuid}`;
+  logger.time(timerLabel, { model: model?.provider_config.model_path });
+  const generateEmbedding = await getPipeline(model, onProgress, {}, signal);
+  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 });
+    return { vector: vectors };
+  }
+  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 });
+  return { vector: hfVector.data };
+};
+
+// src/provider-hf-transformers/common/HFT_TextFillMask.ts
+init_HFT_Pipeline();
+var HFT_TextFillMask = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
+  const unmasker = await getPipeline(model, onProgress, {}, signal);
+  const results = await unmasker(input.text);
+  if (isArrayInput) {
+    return {
+      predictions: results.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((prediction) => ({
+          entity: prediction.token_str,
+          score: prediction.score,
+          sequence: prediction.sequence
+        }));
+      })
+    };
+  }
+  let predictions = [];
+  if (!Array.isArray(results)) {
+    predictions = [results];
+  } else {
+    predictions = results;
+  }
+  return {
     predictions: predictions.map((prediction) => ({
       entity: prediction.token_str,
       score: prediction.score,
@@ -426,17 +1308,22 @@ var HFT_TextFillMask = async (input, model, onProgress, signal) => {
     }))
   };
 };
+
+// src/provider-hf-transformers/common/HFT_TextGeneration.ts
+init_HFT_Pipeline();
+import { getLogger as getLogger6 } from "@workglow/util/worker";
 var HFT_TextGeneration = async (input, model, onProgress, signal) => {
-  const logger = getLogger();
+  const logger = getLogger6();
   const timerLabel = `hft:TextGeneration:${model?.provider_config.model_path}`;
   logger.time(timerLabel, { model: model?.provider_config.model_path });
   const isArrayInput = Array.isArray(input.prompt);
   const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
   logger.debug("HFT TextGeneration: pipeline ready, generating text", {
     model: model?.provider_config.model_path,
     promptLength: isArrayInput ? input.prompt.length : input.prompt?.length
   });
-  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress);
+  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
   let results = await generateText(input.prompt, {
     ...streamer ? { streamer } : {}
   });
@@ -451,440 +1338,142 @@ var HFT_TextGeneration = async (input, model, onProgress, signal) => {
   }
   if (!Array.isArray(results)) {
     results = [results];
-  }
-  const text = extractGeneratedText(results[0]?.generated_text);
-  logger.timeEnd(timerLabel, { outputLength: text?.length });
-  return {
-    text
-  };
-};
-var HFT_TextTranslation = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
-  const translate = await getPipeline(model, onProgress, {}, signal);
-  const streamer = isArrayInput ? undefined : createTextStreamer(translate.tokenizer, onProgress);
-  const result = await translate(input.text, {
-    src_lang: input.source_lang,
-    tgt_lang: input.target_lang,
-    ...streamer ? { streamer } : {}
-  });
-  if (isArrayInput) {
-    const batchResults = Array.isArray(result) ? result : [result];
-    return {
-      text: batchResults.map((r) => r?.translation_text || ""),
-      target_lang: input.target_lang
-    };
-  }
-  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 isArrayInput = Array.isArray(input.text);
-  const generateText = await getPipeline(model, onProgress, {}, signal);
-  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress);
-  if (isArrayInput) {
-    const texts = input.text;
-    const promptedTexts = texts.map((t) => (input.prompt ? input.prompt + `
-` : "") + t);
-    let results2 = await generateText(promptedTexts, {});
-    const batchResults = Array.isArray(results2) ? results2 : [results2];
-    const outputTexts = batchResults.map((r, i) => {
-      const seqs = Array.isArray(r) ? r : [r];
-      const text2 = extractGeneratedText(seqs[0]?.generated_text);
-      if (text2 === promptedTexts[i]) {
-        throw new Error("Rewriter failed to generate new text");
-      }
-      return text2;
-    });
-    return { text: outputTexts };
-  }
-  const promptedText = (input.prompt ? input.prompt + `
-` : "") + input.text;
-  let results = await generateText(promptedText, {
-    ...streamer ? { streamer } : {}
-  });
-  if (!Array.isArray(results)) {
-    results = [results];
-  }
-  const text = extractGeneratedText(results[0]?.generated_text);
-  if (text === promptedText) {
-    throw new Error("Rewriter failed to generate new text");
-  }
-  return {
-    text
-  };
-};
-var HFT_TextSummary = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
-  const generateSummary = await getPipeline(model, onProgress, {}, signal);
-  const streamer = isArrayInput ? undefined : createTextStreamer(generateSummary.tokenizer, onProgress);
-  const result = await generateSummary(input.text, {
-    ...streamer ? { streamer } : {}
-  });
-  if (isArrayInput) {
-    const batchResults = Array.isArray(result) ? result : [result];
-    return {
-      text: batchResults.map((r) => r?.summary_text || "")
-    };
-  }
-  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 isArrayInput = Array.isArray(input.question);
-  const generateAnswer = await getPipeline(model, onProgress, {}, signal);
-  if (isArrayInput) {
-    const questions = input.question;
-    const contexts = input.context;
-    if (questions.length !== contexts.length) {
-      throw new Error(`question[] and context[] must have the same length: ${questions.length} != ${contexts.length}`);
-    }
-    const answers = [];
-    for (let i = 0;i < questions.length; i++) {
-      const result2 = await generateAnswer(questions[i], contexts[i], {});
-      let answerText2 = "";
-      if (Array.isArray(result2)) {
-        answerText2 = result2[0]?.answer || "";
-      } else {
-        answerText2 = result2?.answer || "";
-      }
-      answers.push(answerText2);
-    }
-    return { text: answers };
-  }
-  const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress);
-  const result = await generateAnswer(input.question, input.context, {
-    streamer
-  });
-  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, {}, signal);
-  const result = await segmenter(input.image, {
-    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: {}
-  })));
-  return {
-    masks: processedMasks
-  };
-};
-var HFT_ImageToText = async (input, model, onProgress, signal) => {
-  const captioner = await getPipeline(model, onProgress, {}, signal);
-  const result = await captioner(input.image, {
-    max_new_tokens: input.maxTokens
-  });
-  const text = Array.isArray(result) ? result[0]?.generated_text : result?.generated_text;
+  }
+  const text = extractGeneratedText(results[0]?.generated_text);
+  logger.timeEnd(timerLabel, { outputLength: text?.length });
   return {
-    text: text || ""
+    text
   };
 };
-var HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
-  const remover = await getPipeline(model, onProgress, {}, signal);
-  const result = await remover(input.image);
-  const resultImage = Array.isArray(result) ? result[0] : result;
-  return {
-    image: imageToBase64(resultImage)
-  };
+var HFT_TextGeneration_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const pipelinePromise = generateText(input.prompt, {
+    streamer
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
 };
-var HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
-  const logger = getLogger();
-  const timerLabel = `hft:ImageEmbedding:${model?.provider_config.model_path}`;
-  logger.time(timerLabel, { model: model?.provider_config.model_path });
-  const embedder = await getPipeline(model, onProgress, {}, signal);
-  logger.debug("HFT ImageEmbedding: pipeline ready, generating embedding", {
-    model: model?.provider_config.model_path
+
+// src/provider-hf-transformers/common/HFT_TextLanguageDetection.ts
+init_HFT_Pipeline();
+var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
+  const TextClassification = await getPipeline(model, onProgress, {}, signal);
+  const result = await TextClassification(input.text, {
+    top_k: input.maxLanguages || undefined
   });
-  const result = await embedder(input.image);
-  logger.timeEnd(timerLabel, { dimensions: result?.data?.length });
-  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, {}, signal);
-    const result2 = await zeroShotClassifier(input.image, input.categories, {});
-    const results2 = Array.isArray(result2) ? result2 : [result2];
+  if (isArrayInput) {
     return {
-      categories: results2.map((r) => ({
-        label: r.label,
-        score: r.score
-      }))
+      languages: result.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((category) => ({
+          language: category.label,
+          score: category.score
+        }));
+      })
     };
   }
-  const classifier = await getPipeline(model, onProgress, {}, signal);
-  const result = await classifier(input.image, {
-    top_k: input.maxCategories
-  });
-  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, {}, signal);
-    const result2 = await zeroShotDetector(input.image, Array.from(input.labels), {
-      threshold: input.threshold
-    });
-    const detections2 = Array.isArray(result2) ? result2 : [result2];
+  if (Array.isArray(result[0])) {
     return {
-      detections: detections2.map((d) => ({
-        label: d.label,
-        score: d.score,
-        box: d.box
+      languages: result[0].map((category) => ({
+        language: category.label,
+        score: category.score
       }))
     };
   }
-  const detector = await getPipeline(model, onProgress, {}, signal);
-  const result = await detector(input.image, {
-    threshold: input.threshold
-  });
-  const detections = Array.isArray(result) ? result : [result];
   return {
-    detections: detections.map((d) => ({
-      label: d.label,
-      score: d.score,
-      box: d.box
+    languages: result.map((category) => ({
+      language: category.label,
+      score: category.score
     }))
   };
 };
-function imageToBase64(image) {
-  return image.toBase64?.() || "";
-}
-function createTextStreamer(tokenizer, updateProgress) {
-  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 });
-    }
+
+// src/provider-hf-transformers/common/HFT_TextNamedEntityRecognition.ts
+init_HFT_Pipeline();
+var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
+  const textNamedEntityRecognition = await getPipeline(model, onProgress, {}, signal);
+  const results = await textNamedEntityRecognition(input.text, {
+    ignore_labels: input.blockList
   });
-}
-function extractGeneratedText(generatedText) {
-  if (generatedText == null)
-    return "";
-  if (typeof generatedText === "string")
-    return generatedText;
-  const lastMessage = generatedText[generatedText.length - 1];
-  if (!lastMessage)
-    return "";
-  const content = lastMessage.content;
-  if (typeof content === "string")
-    return content;
-  for (const part of content) {
-    if (part.type === "text" && "text" in part) {
-      return part.text;
-    }
+  if (isArrayInput) {
+    return {
+      entities: results.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((entity) => ({
+          entity: entity.entity,
+          score: entity.score,
+          word: entity.word
+        }));
+      })
+    };
   }
-  return "";
-}
-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) {
-  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 });
-    }
-  });
-}
-function createToolCallMarkupFilter(emit) {
-  const OPEN_TAG = "<tool_call>";
-  const CLOSE_TAG = "</tool_call>";
-  let state = "text";
-  let pending = "";
-  function feed(token) {
-    if (state === "tag") {
-      pending += token;
-      const closeIdx = pending.indexOf(CLOSE_TAG);
-      if (closeIdx !== -1) {
-        const afterClose = pending.slice(closeIdx + CLOSE_TAG.length);
-        pending = "";
-        state = "text";
-        if (afterClose.length > 0) {
-          feed(afterClose);
-        }
-      }
-      return;
-    }
-    const combined = pending + token;
-    const openIdx = combined.indexOf(OPEN_TAG);
-    if (openIdx !== -1) {
-      const before = combined.slice(0, openIdx);
-      if (before.length > 0) {
-        emit(before);
-      }
-      pending = "";
-      state = "tag";
-      const afterOpen = combined.slice(openIdx + OPEN_TAG.length);
-      if (afterOpen.length > 0) {
-        feed(afterOpen);
-      }
-      return;
-    }
-    let prefixLen = 0;
-    for (let len = Math.min(combined.length, OPEN_TAG.length - 1);len >= 1; len--) {
-      if (combined.endsWith(OPEN_TAG.slice(0, len))) {
-        prefixLen = len;
-        break;
-      }
+  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
+    }))
+  };
+};
+
+// src/provider-hf-transformers/common/HFT_TextQuestionAnswer.ts
+init_HFT_Pipeline();
+var HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.question);
+  const generateAnswer = await getPipeline(model, onProgress, {}, signal);
+  if (isArrayInput) {
+    const questions = input.question;
+    const contexts = input.context;
+    if (questions.length !== contexts.length) {
+      throw new Error(`question[] and context[] must have the same length: ${questions.length} != ${contexts.length}`);
     }
-    if (prefixLen > 0) {
-      const safe = combined.slice(0, combined.length - prefixLen);
-      if (safe.length > 0) {
-        emit(safe);
-      }
-      pending = combined.slice(combined.length - prefixLen);
-    } else {
-      if (combined.length > 0) {
-        emit(combined);
+    const answers = [];
+    for (let i = 0;i < questions.length; i++) {
+      const result2 = await generateAnswer(questions[i], contexts[i], {});
+      let answerText2 = "";
+      if (Array.isArray(result2)) {
+        answerText2 = result2[0]?.answer || "";
+      } else {
+        answerText2 = result2?.answer || "";
       }
-      pending = "";
-    }
-  }
-  function flush() {
-    if (pending.length > 0 && state === "text") {
-      emit(pending);
-      pending = "";
+      answers.push(answerText2);
     }
-    pending = "";
-    state = "text";
+    return { text: answers };
   }
-  return { feed, flush };
-}
-var HFT_TextGeneration_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const generateText = await getPipeline(model, noopProgress, {}, signal);
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue);
-  const pipelinePromise = generateText(input.prompt, {
-    streamer
-  }).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, {}, signal);
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue);
-  const promptedText = (input.prompt ? input.prompt + `
-` : "") + input.text;
-  const pipelinePromise = generateText(promptedText, {
-    streamer
-  }).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, {}, signal);
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue);
-  const pipelinePromise = generateSummary(input.text, {
+  const { TextStreamer } = await loadTransformersSDK();
+  const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress, TextStreamer);
+  const result = await generateAnswer(input.question, input.context, {
     streamer
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  yield { type: "finish", data: {} };
+  });
+  let answerText = "";
+  if (Array.isArray(result)) {
+    answerText = result[0]?.answer || "";
+  } else {
+    answerText = result?.answer || "";
+  }
+  return {
+    text: answerText
+  };
 };
 var HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
   const noopProgress = () => {};
   const generateAnswer = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
   const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue);
+  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue, TextStreamer);
   let pipelineResult;
   const pipelinePromise = generateAnswer(input.question, input.context, {
     streamer
@@ -904,153 +1493,159 @@ var HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
   }
   yield { type: "finish", data: { text: answerText } };
 };
-var HFT_TextTranslation_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const translate = await getPipeline(model, noopProgress, {}, 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
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  yield { type: "finish", data: { target_lang: input.target_lang } };
-};
-var HFT_CountTokens = async (input, model, onProgress, signal) => {
+
+// src/provider-hf-transformers/common/HFT_TextRewriter.ts
+init_HFT_Pipeline();
+var HFT_TextRewriter = async (input, model, onProgress, signal) => {
   const isArrayInput = Array.isArray(input.text);
-  const { AutoTokenizer } = _transformersSdk;
-  const tokenizer = await AutoTokenizer.from_pretrained(model.provider_config.model_path, {
-    progress_callback: (progress) => onProgress(progress?.progress ?? 0)
-  });
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
   if (isArrayInput) {
     const texts = input.text;
-    const counts = texts.map((t) => tokenizer.encode(t).length);
-    return { count: counts };
+    const promptedTexts = texts.map((t) => (input.prompt ? input.prompt + `
+` : "") + t);
+    let results2 = await generateText(promptedTexts, {});
+    const batchResults = Array.isArray(results2) ? results2 : [results2];
+    const outputTexts = batchResults.map((r, i) => {
+      const seqs = Array.isArray(r) ? r : [r];
+      const text2 = extractGeneratedText(seqs[0]?.generated_text);
+      if (text2 === promptedTexts[i]) {
+        throw new Error("Rewriter failed to generate new text");
+      }
+      return text2;
+    });
+    return { text: outputTexts };
   }
-  const tokenIds = tokenizer.encode(input.text);
-  return { count: tokenIds.length };
-};
-var HFT_CountTokens_Reactive = async (input, _output, model) => {
-  return HFT_CountTokens(input, model, () => {}, new AbortController().signal);
-};
-function mapHFTTools(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    function: {
-      name: t.name,
-      description: buildToolDescription(t),
-      parameters: t.inputSchema
-    }
-  }));
-}
-function parseToolCallsFromText(responseText) {
-  const toolCalls = [];
-  let callIndex = 0;
-  let cleanedText = responseText;
-  const toolCallTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
-  let tagMatch;
-  while ((tagMatch = toolCallTagRegex.exec(responseText)) !== null) {
-    try {
-      const parsed = JSON.parse(tagMatch[1].trim());
-      const id = `call_${callIndex++}`;
-      toolCalls.push({
-        id,
-        name: parsed.name ?? parsed.function?.name ?? "",
-        input: parsed.arguments ?? parsed.function?.arguments ?? parsed.parameters ?? {}
-      });
-    } catch {}
+  const promptedText = (input.prompt ? input.prompt + `
+` : "") + input.text;
+  let results = await generateText(promptedText, {
+    ...streamer ? { streamer } : {}
+  });
+  if (!Array.isArray(results)) {
+    results = [results];
   }
-  if (toolCalls.length > 0) {
-    cleanedText = responseText.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "").trim();
-    return { text: cleanedText, toolCalls };
+  const text = extractGeneratedText(results[0]?.generated_text);
+  if (text === promptedText) {
+    throw new Error("Rewriter failed to generate new text");
   }
-  const jsonCandidates = [];
-  (function collectBalancedJsonBlocks(source) {
-    const length = source.length;
-    let i = 0;
-    while (i < length) {
-      if (source[i] !== "{") {
-        i++;
-        continue;
-      }
-      let depth = 1;
-      let j = i + 1;
-      let inString = false;
-      let escape = false;
-      while (j < length && depth > 0) {
-        const ch = source[j];
-        if (inString) {
-          if (escape) {
-            escape = false;
-          } else if (ch === "\\") {
-            escape = true;
-          } else if (ch === '"') {
-            inString = false;
-          }
-        } else {
-          if (ch === '"') {
-            inString = true;
-          } else if (ch === "{") {
-            depth++;
-          } else if (ch === "}") {
-            depth--;
-          }
-        }
-        j++;
-      }
-      if (depth === 0) {
-        jsonCandidates.push({ text: source.slice(i, j), start: i, end: j });
-        i = j;
-      } else {
-        break;
-      }
-    }
-  })(responseText);
-  const matchedRanges = [];
-  for (const candidate of jsonCandidates) {
-    try {
-      const parsed = JSON.parse(candidate.text);
-      if (parsed.name && (parsed.arguments !== undefined || parsed.parameters !== undefined)) {
-        const id = `call_${callIndex++}`;
-        toolCalls.push({
-          id,
-          name: parsed.name,
-          input: parsed.arguments ?? parsed.parameters ?? {}
-        });
-        matchedRanges.push({ start: candidate.start, end: candidate.end });
-      } else if (parsed.function?.name) {
-        let functionArgs = parsed.function.arguments ?? {};
-        if (typeof functionArgs === "string") {
-          try {
-            functionArgs = JSON.parse(functionArgs);
-          } catch (innerError) {
-            console.warn("Failed to parse tool call function.arguments as JSON", innerError);
-            functionArgs = {};
-          }
-        }
-        const id = `call_${callIndex++}`;
-        toolCalls.push({
-          id,
-          name: parsed.function.name,
-          input: functionArgs ?? {}
-        });
-        matchedRanges.push({ start: candidate.start, end: candidate.end });
-      }
-    } catch {}
+  return {
+    text
+  };
+};
+var HFT_TextRewriter_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const promptedText = (input.prompt ? input.prompt + `
+` : "") + input.text;
+  const pipelinePromise = generateText(promptedText, {
+    streamer
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+};
+
+// src/provider-hf-transformers/common/HFT_TextSummary.ts
+init_HFT_Pipeline();
+var HFT_TextSummary = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
+  const generateSummary = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const streamer = isArrayInput ? undefined : createTextStreamer(generateSummary.tokenizer, onProgress, TextStreamer);
+  const result = await generateSummary(input.text, {
+    ...streamer ? { streamer } : {}
+  });
+  if (isArrayInput) {
+    const batchResults = Array.isArray(result) ? result : [result];
+    return {
+      text: batchResults.map((r) => r?.summary_text || "")
+    };
   }
-  if (toolCalls.length > 0) {
-    let result = "";
-    let lastIndex = 0;
-    for (const range of matchedRanges) {
-      result += responseText.slice(lastIndex, range.start);
-      lastIndex = range.end;
-    }
-    result += responseText.slice(lastIndex);
-    cleanedText = result.trim();
+  let summaryText = "";
+  if (Array.isArray(result)) {
+    summaryText = result[0]?.summary_text || "";
+  } else {
+    summaryText = result?.summary_text || "";
   }
-  return { text: cleanedText, toolCalls };
+  return {
+    text: summaryText
+  };
+};
+var HFT_TextSummary_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateSummary = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue, TextStreamer);
+  const pipelinePromise = generateSummary(input.text, {
+    streamer
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+};
+
+// src/provider-hf-transformers/common/HFT_TextTranslation.ts
+init_HFT_Pipeline();
+var HFT_TextTranslation = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
+  const translate = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const streamer = isArrayInput ? undefined : createTextStreamer(translate.tokenizer, onProgress, TextStreamer);
+  const result = await translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    ...streamer ? { streamer } : {}
+  });
+  if (isArrayInput) {
+    const batchResults = Array.isArray(result) ? result : [result];
+    return {
+      text: batchResults.map((r) => r?.translation_text || ""),
+      target_lang: input.target_lang
+    };
+  }
+  const translatedText = Array.isArray(result) ? result[0]?.translation_text || "" : result?.translation_text || "";
+  return {
+    text: translatedText,
+    target_lang: input.target_lang
+  };
+};
+var HFT_TextTranslation_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const translate = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(translate.tokenizer, queue, TextStreamer);
+  const pipelinePromise = translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    streamer
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: { target_lang: input.target_lang } };
+};
+
+// src/provider-hf-transformers/common/HFT_ToolCalling.ts
+init_HFT_Pipeline();
+import {
+  buildToolDescription,
+  filterValidToolCalls,
+  toTextFlatMessages
+} from "@workglow/ai/worker";
+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") {
@@ -1077,6 +1672,7 @@ ${requiredInstruction}` };
 var HFT_ToolCalling = async (input, model, onProgress, signal) => {
   const isArrayInput = Array.isArray(input.prompt);
   const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
   if (isArrayInput) {
     const prompts = input.prompt;
     const texts = [];
@@ -1090,7 +1686,7 @@ var HFT_ToolCalling = async (input, model, onProgress, signal) => {
         tokenize: false,
         add_generation_prompt: true
       });
-      const streamer2 = createTextStreamer(generateText.tokenizer, onProgress);
+      const streamer2 = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
       let results2 = await generateText(prompt2, {
         max_new_tokens: input.maxTokens ?? 1024,
         temperature: input.temperature ?? undefined,
@@ -1114,7 +1710,7 @@ var HFT_ToolCalling = async (input, model, onProgress, signal) => {
     tokenize: false,
     add_generation_prompt: true
   });
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress);
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
   let results = await generateText(prompt, {
     max_new_tokens: input.maxTokens ?? 1024,
     temperature: input.temperature ?? undefined,
@@ -1134,6 +1730,7 @@ var HFT_ToolCalling = async (input, model, onProgress, signal) => {
 var HFT_ToolCalling_Stream = async function* (input, model, signal) {
   const noopProgress = () => {};
   const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
   const messages = toTextFlatMessages(input);
   const tools = resolveHFTToolsAndMessages(input, messages);
   const prompt = generateText.tokenizer.apply_chat_template(messages, {
@@ -1143,7 +1740,7 @@ var HFT_ToolCalling_Stream = async function* (input, model, signal) {
   });
   const innerQueue = createStreamEventQueue();
   const outerQueue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, innerQueue);
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, innerQueue, TextStreamer);
   let fullText = "";
   const filter = createToolCallMarkupFilter((text) => {
     outerQueue.push({ type: "text-delta", port: "text", textDelta: text });
@@ -1188,147 +1785,61 @@ var HFT_ToolCalling_Stream = async function* (input, model, signal) {
     data: { text: cleanedText, toolCalls: validToolCalls }
   };
 };
-var HFT_ModelInfo = async (input, model) => {
-  const logger = getLogger();
-  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 = pipelines.has(getPipelineCacheKey(model));
-  const { pipeline: pipelineType, model_path, dtype, device } = model.provider_config;
-  const cacheStatus = await ModelRegistry.is_pipeline_cached_files(pipelineType, model_path, {
-    ...dtype ? { dtype } : {}
-  });
-  logger.debug("is_pipeline_cached", {
-    input: [
-      pipelineType,
-      model_path,
-      {
-        ...dtype ? { dtype } : {}
-      }
-    ],
-    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;
-    }
-  }
-  logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
-  return {
-    model: input.model,
-    is_local: true,
-    is_remote: false,
-    supports_browser: true,
-    supports_node: true,
-    is_cached,
-    is_loaded,
-    file_sizes
-  };
-};
-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.`;
+// src/provider-hf-transformers/common/HFT_Unload.ts
+init_HFT_Pipeline();
+function hasBrowserCacheStorage() {
+  return typeof globalThis !== "undefined" && "caches" in globalThis && typeof globalThis.caches?.open === "function";
 }
-function extractJsonFromText(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    const match = text.match(/\{[\s\S]*\}/);
-    if (match) {
-      try {
-        return JSON.parse(match[0]);
-      } catch {
-        return parsePartialJson(match[0]) ?? {};
+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);
     }
-    return {};
   }
 }
-var HFT_StructuredGeneration = async (input, model, onProgress, signal) => {
-  const generateText = await getPipeline(model, onProgress, {}, signal);
-  const prompt = buildStructuredGenerationPrompt(input);
-  const messages = [{ role: "user", content: prompt }];
-  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
-    tokenize: false,
-    add_generation_prompt: true
-  });
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress);
-  let results = await generateText(formattedPrompt, {
-    max_new_tokens: input.maxTokens ?? 1024,
-    temperature: input.temperature ?? undefined,
-    return_full_text: false,
-    streamer
+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 } : {}
   });
-  if (!Array.isArray(results)) {
-    results = [results];
+}
+var HFT_Unload = async (input, model, onProgress, _signal) => {
+  const cacheKey = getPipelineCacheKey(model);
+  if (removeCachedPipeline(cacheKey)) {
+    onProgress(50, "Pipeline removed from memory");
   }
-  const responseText = extractGeneratedText(results[0]?.generated_text).trim();
-  const object = extractJsonFromText(responseText);
-  return { object };
-};
-var HFT_StructuredGeneration_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const generateText = await getPipeline(model, noopProgress, {}, signal);
-  const prompt = buildStructuredGenerationPrompt(input);
-  const messages = [{ role: "user", content: prompt }];
-  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
-    tokenize: false,
-    add_generation_prompt: true
-  });
-  const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue);
-  let fullText = "";
-  const originalPush = queue.push;
-  queue.push = (event) => {
-    if (event.type === "text-delta" && "textDelta" in event) {
-      fullText += event.textDelta;
-      const match = fullText.match(/\{[\s\S]*/);
-      if (match) {
-        const partial = parsePartialJson(match[0]);
-        if (partial !== undefined) {
-          originalPush({
-            type: "object-delta",
-            port: "object",
-            objectDelta: partial
-          });
-          return;
-        }
-      }
-    }
-    originalPush(event);
+  const model_path = model.provider_config.model_path;
+  if (hasBrowserCacheStorage()) {
+    await deleteModelCacheFromBrowser(model_path);
+  } else {
+    await deleteModelCacheFromFilesystem(model);
+  }
+  onProgress(100, "Model cache deleted");
+  return {
+    model: input.model
   };
-  const pipelinePromise = generateText(formattedPrompt, {
-    max_new_tokens: input.maxTokens ?? 1024,
-    temperature: input.temperature ?? undefined,
-    return_full_text: false,
-    streamer
-  }).then(() => queue.done(), (err) => queue.error(err));
-  yield* queue.iterable;
-  await pipelinePromise;
-  const object = extractJsonFromText(fullText);
-  yield { type: "finish", data: { object } };
 };
+
+// src/provider-hf-transformers/common/HFT_JobRunFns.ts
 var HFT_TASKS = {
   DownloadModelTask: HFT_Download,
   UnloadModelTask: HFT_Unload,
@@ -1351,7 +1862,8 @@ var HFT_TASKS = {
   ImageClassificationTask: HFT_ImageClassification,
   ObjectDetectionTask: HFT_ObjectDetection,
   ToolCallingTask: HFT_ToolCalling,
-  StructuredGenerationTask: HFT_StructuredGeneration
+  StructuredGenerationTask: HFT_StructuredGeneration,
+  ModelSearchTask: HFT_ModelSearch
 };
 var HFT_STREAM_TASKS = {
   TextGenerationTask: HFT_TextGeneration_Stream,
@@ -1366,6 +1878,130 @@ var HFT_REACTIVE_TASKS = {
   CountTokensTask: HFT_CountTokens_Reactive
 };
 
-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, createToolCallMarkupFilter, HFT_TextGeneration_Stream, HFT_TextRewriter_Stream, HFT_TextSummary_Stream, HFT_TextQuestionAnswer_Stream, HFT_TextTranslation_Stream, HFT_CountTokens, HFT_CountTokens_Reactive, parseToolCallsFromText, HFT_ToolCalling, HFT_ToolCalling_Stream, HFT_ModelInfo, HFT_StructuredGeneration, HFT_StructuredGeneration_Stream, HFT_TASKS, HFT_STREAM_TASKS, HFT_REACTIVE_TASKS };
+// src/provider-hf-transformers/HuggingFaceTransformersQueuedProvider.ts
+import {
+  QueuedAiProvider
+} from "@workglow/ai";
+class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
+  name = HF_TRANSFORMERS_ONNX;
+  isLocal = true;
+  supportsBrowser = true;
+  taskTypes = [
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "ModelInfoTask",
+    "CountTokensTask",
+    "TextEmbeddingTask",
+    "TextGenerationTask",
+    "TextQuestionAnswerTask",
+    "TextLanguageDetectionTask",
+    "TextClassificationTask",
+    "TextFillMaskTask",
+    "TextNamedEntityRecognitionTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "TextTranslationTask",
+    "ImageSegmentationTask",
+    "ImageToTextTask",
+    "BackgroundRemovalTask",
+    "ImageEmbeddingTask",
+    "ImageClassificationTask",
+    "ObjectDetectionTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-hf-transformers/registerHuggingFaceTransformersInline.ts
+init_HFT_Pipeline();
+async function registerHuggingFaceTransformersInline(options) {
+  const { env } = await loadTransformersSDK();
+  env.backends.onnx.wasm.proxy = true;
+  const provider = new HuggingFaceTransformersQueuedProvider(HFT_TASKS, HFT_STREAM_TASKS, HFT_REACTIVE_TASKS);
+  const baseDispose = provider.dispose.bind(provider);
+  provider.dispose = async () => {
+    await clearHftInlinePipelineCache();
+    await baseDispose();
+  };
+  await provider.register(options ?? {});
+}
+// src/provider-hf-transformers/registerHuggingFaceTransformersWorker.ts
+import { getLogger as getLogger7, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+
+// src/provider-hf-transformers/HuggingFaceTransformersProvider.ts
+import {
+  AiProvider
+} from "@workglow/ai/worker";
+class HuggingFaceTransformersProvider extends AiProvider {
+  name = HF_TRANSFORMERS_ONNX;
+  isLocal = true;
+  supportsBrowser = true;
+  taskTypes = [
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "ModelInfoTask",
+    "CountTokensTask",
+    "TextEmbeddingTask",
+    "TextGenerationTask",
+    "TextQuestionAnswerTask",
+    "TextLanguageDetectionTask",
+    "TextClassificationTask",
+    "TextFillMaskTask",
+    "TextNamedEntityRecognitionTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "TextTranslationTask",
+    "ImageSegmentationTask",
+    "ImageToTextTask",
+    "BackgroundRemovalTask",
+    "ImageEmbeddingTask",
+    "ImageClassificationTask",
+    "ObjectDetectionTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-hf-transformers/registerHuggingFaceTransformersWorker.ts
+init_HFT_Pipeline();
+async function registerHuggingFaceTransformersWorker() {
+  const { env } = await loadTransformersSDK();
+  env.backends.onnx.wasm.proxy = true;
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  new HuggingFaceTransformersProvider(HFT_TASKS, HFT_STREAM_TASKS, HFT_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
+  workerServer.sendReady();
+  getLogger7().info("HuggingFaceTransformers worker job run functions registered");
+}
+
+// src/provider-hf-transformers/runtime.ts
+init_HFT_Pipeline();
+export {
+  setHftCacheDir,
+  removeCachedPipeline,
+  registerHuggingFaceTransformersWorker,
+  registerHuggingFaceTransformersInline,
+  parseToolCallsFromText,
+  parseOnnxQuantizations,
+  loadTransformersSDK,
+  hasCachedPipeline,
+  getPipelineCacheKey,
+  getPipeline,
+  createToolCallMarkupFilter,
+  clearPipelineCache,
+  QuantizationDataType,
+  PipelineUseCase,
+  ONNX_QUANTIZATION_SUFFIX_MAPPING,
+  HfTransformersOnnxModelSchema,
+  HfTransformersOnnxModelRecordSchema,
+  HfTransformersOnnxModelConfigSchema,
+  HTF_CACHE_NAME,
+  HF_TRANSFORMERS_ONNX
+};
 
-//# debugId=84170CBF73939EA164756E2164756E21
+//# debugId=8397F27EBE0B0C0B64756E2164756E21