@workglow/huggingface-transformers 0.2.28

package/dist/ai-provider-runtime.js

@@ -0,0 +1,2367 @@
+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/ai-provider/common/HFT_Pipeline.ts
+var exports_HFT_Pipeline = {};
+__export(exports_HFT_Pipeline, {
+  setHftSession: () => setHftSession,
+  setHftCacheDir: () => setHftCacheDir,
+  removeCachedPipeline: () => removeCachedPipeline,
+  loadTransformersSDK: () => loadTransformersSDK,
+  hasCachedPipeline: () => hasCachedPipeline,
+  getPipelineCacheKey: () => getPipelineCacheKey,
+  getPipeline: () => getPipeline,
+  getHftSession: () => getHftSession,
+  disposeHftSessionsForModel: () => disposeHftSessionsForModel,
+  deleteHftSession: () => deleteHftSession,
+  clearPipelineCache: () => clearPipelineCache,
+  HFT_NULL_PROCESSOR_PREFIX: () => HFT_NULL_PROCESSOR_PREFIX
+});
+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;
+}
+function combineAbortSignals(existingSignal, modelSignal) {
+  if (!existingSignal) {
+    return modelSignal;
+  }
+  if (!modelSignal) {
+    return existingSignal;
+  }
+  if (existingSignal.aborted || modelSignal.aborted) {
+    return AbortSignal.abort(existingSignal.reason ?? modelSignal.reason);
+  }
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([existingSignal, modelSignal]);
+  }
+  const controller = new AbortController;
+  const abort = (event) => {
+    const signal = event.target;
+    controller.abort(signal.reason);
+  };
+  existingSignal.addEventListener("abort", abort, { once: true });
+  modelSignal.addEventListener("abort", abort, { once: true });
+  return controller.signal;
+}
+function createAbortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    return reason;
+  }
+  return new Error(String(reason ?? "Fetch aborted"));
+}
+function wrapAbortableResponse(response, signal) {
+  if (!signal || !response.body) {
+    return response;
+  }
+  const contentLengthHeader = response.headers.get("content-length");
+  const expectedSize = contentLengthHeader && /^\d+$/.test(contentLengthHeader) ? Number.parseInt(contentLengthHeader, 10) : undefined;
+  const sourceBody = response.body;
+  let reader;
+  let abortHandler;
+  let loaded = 0;
+  const cleanup = () => {
+    if (abortHandler) {
+      signal.removeEventListener("abort", abortHandler);
+      abortHandler = undefined;
+    }
+    reader?.releaseLock();
+  };
+  const body = new ReadableStream({
+    start(controller) {
+      reader = sourceBody.getReader();
+      if (signal.aborted) {
+        controller.error(createAbortError(signal));
+        return;
+      }
+      abortHandler = () => controller.error(createAbortError(signal));
+      signal.addEventListener("abort", abortHandler, { once: true });
+    },
+    async pull(controller) {
+      try {
+        if (signal.aborted) {
+          throw createAbortError(signal);
+        }
+        const { done, value } = await reader.read();
+        if (done) {
+          if (signal.aborted) {
+            throw createAbortError(signal);
+          }
+          if (expectedSize !== undefined && loaded < expectedSize) {
+            throw new Error(`Fetch ended before reading the full response body (${loaded}/${expectedSize} bytes)`);
+          }
+          cleanup();
+          controller.close();
+          return;
+        }
+        loaded += value.length;
+        controller.enqueue(value);
+      } catch (error) {
+        cleanup();
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      cleanup();
+      return sourceBody.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    headers: new Headers(response.headers),
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function abortableFetch(url, options) {
+  let modelSignal;
+  try {
+    const pathname = new URL(url).pathname;
+    for (const [modelPath, controller] of modelAbortControllers) {
+      if (pathname.includes(`/${modelPath}/`)) {
+        modelSignal = controller.signal;
+        break;
+      }
+    }
+  } catch {}
+  const combinedSignal = options?.signal ? combineAbortSignals(options.signal, modelSignal) : modelSignal;
+  return fetch(url, { ...options, ...combinedSignal ? { signal: combinedSignal } : {} }).then((response) => wrapAbortableResponse(response, combinedSignal));
+}
+function getHftSession(sessionId) {
+  return hftSessions.get(sessionId);
+}
+function setHftSession(sessionId, state) {
+  hftSessions.set(sessionId, state);
+}
+function disposeSessionResources(session) {
+  if (session.mode === "progressive") {
+    if (session.cache?.dispose) {
+      session.cache.dispose();
+    }
+  } else {
+    for (const tensor of Object.values(session.baseEntries)) {
+      if (tensor?.location === "gpu-buffer" && typeof tensor.dispose === "function") {
+        tensor.dispose();
+      }
+    }
+  }
+}
+function deleteHftSession(sessionId) {
+  const session = hftSessions.get(sessionId);
+  if (session) {
+    disposeSessionResources(session);
+  }
+  return hftSessions.delete(sessionId);
+}
+function disposeHftSessionsForModel(modelPath) {
+  for (const [id, state] of hftSessions) {
+    if (state.modelPath === modelPath) {
+      disposeSessionResources(state);
+      hftSessions.delete(id);
+    }
+  }
+}
+function clearPipelineCache() {
+  pipelines.clear();
+}
+function hasCachedPipeline(cacheKey) {
+  return pipelines.has(cacheKey);
+}
+function removeCachedPipeline(cacheKey) {
+  return pipelines.delete(cacheKey);
+}
+function isBrowserEnv() {
+  if (typeof globalThis === "undefined")
+    return false;
+  if (typeof globalThis.window !== "undefined")
+    return true;
+  if (typeof globalThis.WorkerGlobalScope !== "undefined")
+    return true;
+  return false;
+}
+function getPipelineCacheKey(model) {
+  const dtype = model.provider_config.dtype || "";
+  const device = model.provider_config.device || "";
+  const revision = model.provider_config.revision || "main";
+  return `${model.provider_config.model_path}:${model.provider_config.pipeline}:${dtype}:${device}:${revision}`;
+}
+async function getPipeline(model, onProgress, options = {}, signal, progressScaleMax = 10) {
+  const cacheKey = getPipelineCacheKey(model);
+  if (pipelines.has(cacheKey)) {
+    getLogger().debug("HFT pipeline cache hit", { cacheKey });
+    return pipelines.get(cacheKey);
+  }
+  const inFlight = pipelineLoadPromises.get(cacheKey);
+  if (inFlight) {
+    try {
+      await inFlight;
+    } catch {}
+    const cached = pipelines.get(cacheKey);
+    if (cached)
+      return cached;
+  }
+  const loadPromise = doGetPipeline(model, onProgress, options, progressScaleMax, cacheKey, signal).finally(() => {
+    pipelineLoadPromises.delete(cacheKey);
+  });
+  pipelineLoadPromises.set(cacheKey, loadPromise);
+  return loadPromise;
+}
+var _transformersSdk, _cacheDir, modelAbortControllers, pipelines, hftSessions, pipelineLoadPromises, IMAGE_PIPELINE_TYPES, HFT_NULL_PROCESSOR_PREFIX = "HFT_NULL_PROCESSOR:", doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKey, signal) => {
+  let lastProgressTime = 0;
+  let pendingProgress = null;
+  let throttleTimer = null;
+  const THROTTLE_MS = 160;
+  const buildProgressDetails = (file, fileProgress, filesMap) => {
+    const details = {
+      file,
+      progress: fileProgress
+    };
+    if (filesMap && Object.keys(filesMap).length > 0) {
+      details.files = filesMap;
+    }
+    return details;
+  };
+  const sendProgress = (progress, file, fileProgress, filesMap) => {
+    const now = Date.now();
+    const timeSinceLastEvent = now - lastProgressTime;
+    const isFirst = lastProgressTime === 0;
+    const isFinal = progress >= progressScaleMax;
+    if (isFirst || isFinal) {
+      if (throttleTimer) {
+        clearTimeout(throttleTimer);
+        throttleTimer = null;
+      }
+      pendingProgress = null;
+      onProgress(Math.round(progress), "Downloading model", buildProgressDetails(file, fileProgress, filesMap));
+      lastProgressTime = now;
+      return;
+    }
+    if (timeSinceLastEvent < THROTTLE_MS) {
+      pendingProgress = { progress, file, fileProgress, filesMap };
+      if (!throttleTimer) {
+        const timeRemaining = Math.max(1, THROTTLE_MS - timeSinceLastEvent);
+        throttleTimer = setTimeout(() => {
+          throttleTimer = null;
+          if (pendingProgress) {
+            const p = pendingProgress;
+            onProgress(Math.round(p.progress), "Downloading model", buildProgressDetails(p.file, p.fileProgress, p.filesMap));
+            lastProgressTime = Date.now();
+            pendingProgress = null;
+          }
+        }, timeRemaining);
+      }
+      return;
+    }
+    onProgress(Math.round(progress), "Downloading model", buildProgressDetails(file, fileProgress, filesMap));
+    lastProgressTime = now;
+    pendingProgress = null;
+  };
+  const abortSignal = signal;
+  const modelPath = model.provider_config.model_path;
+  const modelController = new AbortController;
+  modelAbortControllers.set(modelPath, modelController);
+  if (abortSignal) {
+    if (abortSignal.aborted) {
+      modelController.abort();
+    } else {
+      abortSignal.addEventListener("abort", () => modelController.abort(), { once: true });
+    }
+  }
+  const progressCallback = (status) => {
+    if (abortSignal?.aborted)
+      return;
+    if (status.status === "progress_total") {
+      const totalStatus = status;
+      const scaledProgress = totalStatus.progress * progressScaleMax / 100;
+      let activeFile = "";
+      let activeFileProgress = 0;
+      const files = totalStatus.files;
+      if (files) {
+        for (const [file, info] of Object.entries(files)) {
+          if (info.loaded < info.total) {
+            activeFile = file;
+            activeFileProgress = info.total > 0 ? info.loaded / info.total * 100 : 0;
+            break;
+          }
+        }
+        if (!activeFile) {
+          const fileNames = Object.keys(files);
+          if (fileNames.length > 0) {
+            activeFile = fileNames[fileNames.length - 1];
+            activeFileProgress = 100;
+          }
+        }
+      }
+      sendProgress(scaledProgress, activeFile, activeFileProgress, files);
+    }
+  };
+  let device = model.provider_config.device;
+  if (isBrowserEnv()) {
+    if (device === "gpu") {
+      device = "webgpu";
+    }
+    if (device === "cpu") {
+      device = "wasm";
+    }
+    if (device !== "wasm" && device !== "webgpu") {
+      device = "wasm";
+    }
+  } else {
+    if (device === "wasm" || device === "webgpu") {
+      device = undefined;
+    }
+  }
+  const dtype = model.provider_config.dtype || "";
+  const pipelineOptions = {
+    revision: model.provider_config.revision || "main",
+    ...model.provider_config.use_external_data_format ? { useExternalDataFormat: model.provider_config.use_external_data_format } : {},
+    ...dtype ? { dtype } : {},
+    ...device ? { device } : {},
+    ...options,
+    progress_callback: progressCallback
+  };
+  if (abortSignal?.aborted) {
+    modelAbortControllers.delete(modelPath);
+    throw new Error("Operation aborted before pipeline creation");
+  }
+  const pipelineType = model.provider_config.pipeline;
+  const { pipeline } = await loadTransformersSDK();
+  const logger = getLogger();
+  const pipelineTimerLabel = `hft:pipeline:${cacheKey}`;
+  logger.time(pipelineTimerLabel, { pipelineType, modelPath });
+  try {
+    const result = await pipeline(pipelineType, model.provider_config.model_path, pipelineOptions);
+    if (throttleTimer) {
+      clearTimeout(throttleTimer);
+      throttleTimer = null;
+    }
+    const finalPending = pendingProgress;
+    if (finalPending) {
+      onProgress(Math.round(finalPending.progress), "Downloading model", buildProgressDetails(finalPending.file, finalPending.fileProgress, finalPending.filesMap));
+      pendingProgress = null;
+    }
+    if (abortSignal?.aborted) {
+      logger.timeEnd(pipelineTimerLabel, { status: "aborted" });
+      throw new Error("Operation aborted after pipeline creation");
+    }
+    if (IMAGE_PIPELINE_TYPES.has(pipelineType) && result.processor == null) {
+      throw new Error(`${HFT_NULL_PROCESSOR_PREFIX} Image processor not initialized for ${pipelineType}/${modelPath}. Model cache may be incomplete.`);
+    }
+    logger.timeEnd(pipelineTimerLabel, { status: "loaded" });
+    pipelines.set(cacheKey, result);
+    return result;
+  } catch (error) {
+    logger.timeEnd(pipelineTimerLabel, { status: "error", error: String(error) });
+    if (!error?.message?.startsWith(HFT_NULL_PROCESSOR_PREFIX) && (abortSignal?.aborted || modelController.signal.aborted)) {
+      throw new Error("Pipeline download aborted");
+    }
+    throw error;
+  } finally {
+    modelAbortControllers.delete(modelPath);
+    const { random } = await loadTransformersSDK();
+    random.seed(model.provider_config.seed ?? undefined);
+  }
+};
+var init_HFT_Pipeline = __esm(() => {
+  modelAbortControllers = new Map;
+  pipelines = new Map;
+  hftSessions = new Map;
+  pipelineLoadPromises = new Map;
+  IMAGE_PIPELINE_TYPES = new Set([
+    "image-classification",
+    "image-segmentation",
+    "object-detection",
+    "image-to-text",
+    "image-feature-extraction",
+    "zero-shot-image-classification",
+    "depth-estimation",
+    "mask-generation"
+  ]);
+});
+
+// src/ai-provider/common/HFT_Constants.ts
+var HF_TRANSFORMERS_ONNX = "HF_TRANSFORMERS_ONNX";
+var HF_TRANSFORMERS_ONNX_GPU = `${HF_TRANSFORMERS_ONNX}_gpu`;
+var HF_TRANSFORMERS_ONNX_CPU = `${HF_TRANSFORMERS_ONNX}_cpu`;
+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",
+  q2: "q2",
+  q2f16: "q2f16",
+  q1: "q1",
+  q1f16: "q1f16"
+};
+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 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/ai-provider/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."
+        },
+        revision: {
+          type: "string",
+          description: "Git revision (branch, tag, or commit hash) of the model repository.",
+          default: "main"
+        },
+        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."
+        },
+        seed: {
+          type: "integer",
+          description: "RNG seed passed to transformers.js sampling. Omit for time-based seeding; set for reproducible generation.",
+          minimum: 0
+        },
+        mrl: {
+          type: "boolean",
+          description: "Whether the model uses matryoshka.",
+          default: false
+        }
+      },
+      required: ["model_path", "pipeline"],
+      additionalProperties: false,
+      if: {
+        properties: {
+          pipeline: {
+            const: "feature-extraction"
+          }
+        }
+      },
+      then: {
+        required: ["native_dimensions"]
+      }
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var HfTransformersOnnxModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...HfTransformersOnnxModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...HfTransformersOnnxModelSchema.required],
+  additionalProperties: false
+};
+var HfTransformersOnnxModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...HfTransformersOnnxModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...HfTransformersOnnxModelSchema.required],
+  additionalProperties: false
+};
+
+// src/ai-provider/common/HFT_OnnxDtypes.ts
+var ONNX_QUANTIZATION_SUFFIX_MAPPING = {
+  fp32: "",
+  fp16: "_fp16",
+  int8: "_int8",
+  uint8: "_uint8",
+  q8: "_quantized",
+  q4: "_q4",
+  q4f16: "_q4f16",
+  bnb4: "_bnb4",
+  q2: "_q2",
+  q2f16: "_q2f16",
+  q1: "_q1",
+  q1f16: "_q1f16"
+};
+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;
+      }
+    }
+    if (!matched) {
+      parsed.push({ baseName: stem, dtype: "fp32" });
+    }
+  }
+  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);
+  }
+  const allDtypes = Object.keys(ONNX_QUANTIZATION_SUFFIX_MAPPING);
+  return allDtypes.filter((dtype) => {
+    const set = byDtype.get(dtype);
+    return set !== undefined && set.size === allBaseNames.size;
+  });
+}
+
+// src/ai-provider/common/HFT_ToolMarkup.ts
+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/ai-provider/registerHuggingFaceTransformersInline.ts
+import { registerProviderInline } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/HFT_InlineLifecycle.ts
+async function clearHftInlinePipelineCache() {
+  const { clearPipelineCache: clearPipelineCache2 } = await Promise.resolve().then(() => (init_HFT_Pipeline(), exports_HFT_Pipeline));
+  clearPipelineCache2();
+}
+
+// src/ai-provider/common/HFT_ModelSearch.ts
+import { searchHfModels, mapHfModelResult } from "@workglow/ai-provider/common";
+var HFT_ModelSearch = async (input, _model, _onProgress, signal) => {
+  const entries = await searchHfModels(input.query?.trim() ?? "", { filter: "onnx" }, ["siblings"], signal);
+  const results = entries.map((entry) => {
+    const item = mapHfModelResult(entry, HF_TRANSFORMERS_ONNX);
+    if (entry.siblings && entry.siblings.length > 0) {
+      const filePaths = entry.siblings.map((s) => s.rfilename);
+      const quantizations = parseOnnxQuantizations({ filePaths });
+      if (quantizations.length > 0) {
+        const record = item.record;
+        const providerConfig = record.provider_config ?? {};
+        providerConfig.quantizations = quantizations;
+        record.provider_config = providerConfig;
+      }
+    }
+    const raw = item.raw;
+    delete raw.siblings;
+    return item;
+  });
+  return { results };
+};
+
+// src/ai-provider/common/HFT_BackgroundRemoval.ts
+init_HFT_Pipeline();
+import { dataUriToImageValue, imageValueToBlob } from "@workglow/ai-provider/common";
+function rawImageToBase64Png(image) {
+  const fn = image.toBase64;
+  if (typeof fn !== "function") {
+    throw new Error("HFT_BackgroundRemoval: RawImage.toBase64 unavailable in this transformers version");
+  }
+  return fn.call(image);
+}
+var HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
+  const remover = await getPipeline(model, onProgress, {}, signal);
+  const imageArg = await imageValueToBlob(input.image);
+  const result = await remover(imageArg);
+  const resultImage = Array.isArray(result) ? result[0] : result;
+  const dataUri = `data:image/png;base64,${rawImageToBase64Png(resultImage)}`;
+  return {
+    image: await dataUriToImageValue(dataUri)
+  };
+};
+
+// src/ai-provider/common/HFT_Chat.ts
+init_HFT_Pipeline();
+
+// src/ai-provider/common/HFT_ToolCalling.ts
+init_HFT_Pipeline();
+import {
+  buildToolDescription,
+  filterValidToolCalls,
+  toTextFlatMessages
+} from "@workglow/ai/worker";
+import {
+  adaptParserResult,
+  forcedToolSelection,
+  getAvailableParsers,
+  getGenerationPrefix,
+  parseToolCalls
+} from "@workglow/ai-provider/common";
+
+// src/ai-provider/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/ai-provider/common/HFT_ToolCalling.ts
+function getModelTextCandidates(model) {
+  return [model.model_id, model.title, model.description, model.provider_config.model_path].filter((value) => typeof value === "string" && value.length > 0).map((value) => value.toLowerCase());
+}
+function detectModelFamilyFromConfig(model) {
+  const candidates = getModelTextCandidates(model);
+  const families = getAvailableParsers();
+  for (const candidate of candidates) {
+    for (const family of families) {
+      if (candidate.includes(family)) {
+        return family;
+      }
+    }
+  }
+  return null;
+}
+function normalizeParsedToolCalls(input, toolCalls) {
+  const forcedToolName = forcedToolSelection(input);
+  return toolCalls.map((toolCall) => toolCall.name ? toolCall : {
+    ...toolCall,
+    name: forcedToolName ?? toolCall.name
+  });
+}
+function mapHFTTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+}
+function resolveHFTToolsAndMessages(input, messages) {
+  if (input.toolChoice === "none") {
+    return;
+  }
+  if (input.toolChoice === "required") {
+    const requiredInstruction = "You must call at least one tool from the provided tool list when answering.";
+    if (messages.length > 0 && messages[0].role === "system") {
+      messages[0] = { ...messages[0], content: `${messages[0].content}
+
+${requiredInstruction}` };
+    } else {
+      messages.unshift({ role: "system", content: requiredInstruction });
+    }
+    return mapHFTTools(input.tools);
+  }
+  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto") {
+    const selectedTools = input.tools?.filter((tool) => tool.name === input.toolChoice);
+    const toolsToMap = selectedTools && selectedTools.length > 0 ? selectedTools : input.tools;
+    return mapHFTTools(toolsToMap);
+  }
+  return mapHFTTools(input.tools);
+}
+function buildHFTMessages(messages, systemPrompt, prompt, toolChoice) {
+  const out = [];
+  if (systemPrompt) {
+    out.push({ role: "system", content: systemPrompt });
+  }
+  if (toolChoice === "required") {
+    out.push({
+      role: "system",
+      content: "You MUST call one of the provided tools in this turn."
+    });
+  }
+  if (!messages || messages.length === 0) {
+    out.push({ role: "user", content: extractPromptText(prompt) });
+    return out;
+  }
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      out.push({ role: "user", content: text });
+    } else if (msg.role === "assistant") {
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => {
+        const tu = b;
+        return { id: tu.id, name: tu.name, arguments: tu.input };
+      });
+      const entry = { role: "assistant", content: text };
+      if (toolCalls.length > 0)
+        entry.tool_calls = toolCalls;
+      out.push(entry);
+    } else if (msg.role === "tool") {
+      for (const b of msg.content) {
+        if (b.type !== "tool_result")
+          continue;
+        const text = b.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
+        out.push({
+          role: "tool",
+          content: text,
+          tool_call_id: b.tool_use_id
+        });
+      }
+    }
+  }
+  return out;
+}
+function extractPromptText(prompt) {
+  if (typeof prompt === "string")
+    return prompt;
+  if (!Array.isArray(prompt))
+    return String(prompt ?? "");
+  return prompt.map((item) => {
+    if (typeof item === "string")
+      return item;
+    if (item && typeof item === "object" && item.type === "text") {
+      return item.text;
+    }
+    return "";
+  }).filter((s) => s).join(`
+`);
+}
+function selectHFTTools(input) {
+  if (input.toolChoice === "none")
+    return;
+  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto" && input.toolChoice !== "required") {
+    const selected = input.tools.filter((t) => t.name === input.toolChoice);
+    return mapHFTTools(selected.length > 0 ? selected : input.tools);
+  }
+  return mapHFTTools(input.tools);
+}
+function hasToolMessages(input) {
+  return input.messages?.some((m) => m.role === "tool") ?? false;
+}
+function buildPromptAndPrefix(tokenizer, input, modelFamily) {
+  let basePrompt;
+  if (hasToolMessages(input)) {
+    const messages = buildHFTMessages(input.messages, input.systemPrompt, input.prompt, input.toolChoice);
+    const tools = selectHFTTools(input);
+    basePrompt = tokenizer.apply_chat_template(messages, {
+      tools,
+      tokenize: false,
+      add_generation_prompt: true
+    });
+  } else {
+    const messages = toTextFlatMessages(input);
+    const tools = resolveHFTToolsAndMessages(input, messages);
+    basePrompt = tokenizer.apply_chat_template(messages, {
+      tools,
+      tokenize: false,
+      add_generation_prompt: true
+    });
+  }
+  const responsePrefix = input.toolChoice === "none" || hasToolMessages(input) ? undefined : getGenerationPrefix(modelFamily, forcedToolSelection(input));
+  return {
+    prompt: responsePrefix ? `${basePrompt}${responsePrefix}` : basePrompt,
+    responsePrefix
+  };
+}
+var HFT_ToolCalling = async (input, model, onProgress, signal, _outputSchema, sessionId) => {
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const hfTokenizer = generateText.tokenizer;
+  const hfModel = generateText.model;
+  const streamer = createTextStreamer(hfTokenizer, onProgress, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const modelFamily = detectModelFamilyFromConfig(model);
+  const { prompt, responsePrefix } = buildPromptAndPrefix(hfTokenizer, input, modelFamily);
+  const inputs = hfTokenizer(prompt, { return_tensor: true });
+  const modelPath = model.provider_config.model_path;
+  let session = sessionId ? getHftSession(sessionId) : undefined;
+  let past_key_values = undefined;
+  if (sessionId && !session) {
+    const { DynamicCache } = await loadTransformersSDK();
+    const cache = new DynamicCache;
+    await hfModel.generate({
+      ...inputs,
+      max_new_tokens: 0,
+      past_key_values: cache
+    });
+    const baseEntries = {};
+    for (const key of Object.keys(cache)) {
+      baseEntries[key] = cache[key];
+    }
+    const newSession = {
+      mode: "prefix-rewind",
+      baseEntries,
+      baseSeqLength: cache.get_seq_length(),
+      modelPath
+    };
+    setHftSession(sessionId, newSession);
+    session = newSession;
+  }
+  if (session?.mode === "prefix-rewind") {
+    const { DynamicCache } = await loadTransformersSDK();
+    past_key_values = new DynamicCache(session.baseEntries);
+  }
+  const output = await hfModel.generate({
+    ...inputs,
+    max_new_tokens: input.maxTokens ?? 1024,
+    streamer,
+    stopping_criteria: [stopping_criteria],
+    ...past_key_values ? { past_key_values } : {}
+  });
+  const promptLen = inputs.input_ids.dims[1];
+  const seqLen = output.dims[1];
+  const newTokens = output.slice(0, [promptLen, seqLen], null);
+  const decoded = hfTokenizer.decode(newTokens, {
+    skip_special_tokens: false
+  });
+  const parseableText = responsePrefix ? `${responsePrefix}${decoded}` : decoded;
+  const { text, toolCalls } = adaptParserResult(parseToolCalls(parseableText, { parser: modelFamily }));
+  return {
+    text,
+    toolCalls: filterValidToolCalls(normalizeParsedToolCalls(input, toolCalls), input.tools)
+  };
+};
+var HFT_ToolCalling_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const modelFamily = detectModelFamilyFromConfig(model);
+  const { prompt, responsePrefix } = buildPromptAndPrefix(generateText.tokenizer, input, modelFamily);
+  const innerQueue = createStreamEventQueue();
+  const outerQueue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, innerQueue, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const modelPath = model.provider_config.model_path;
+  let session = sessionId ? getHftSession(sessionId) : undefined;
+  let past_key_values = undefined;
+  if (sessionId && !session) {
+    const { DynamicCache } = await loadTransformersSDK();
+    const hfModel = generateText.model;
+    const hfTokenizer = generateText.tokenizer;
+    const cache = new DynamicCache;
+    const tokenized = hfTokenizer(prompt);
+    await hfModel.generate({
+      ...tokenized,
+      max_new_tokens: 0,
+      past_key_values: cache
+    });
+    const baseEntries = {};
+    for (const key of Object.keys(cache)) {
+      baseEntries[key] = cache[key];
+    }
+    const newSession = {
+      mode: "prefix-rewind",
+      baseEntries,
+      baseSeqLength: cache.get_seq_length(),
+      modelPath
+    };
+    setHftSession(sessionId, newSession);
+    session = newSession;
+  }
+  if (session?.mode === "prefix-rewind") {
+    const { DynamicCache } = await loadTransformersSDK();
+    past_key_values = new DynamicCache(session.baseEntries);
+  }
+  let fullText = "";
+  const filter = createToolCallMarkupFilter((text) => {
+    outerQueue.push({ type: "text-delta", port: "text", textDelta: text });
+  });
+  const originalPush = innerQueue.push;
+  innerQueue.push = (event) => {
+    if (event.type === "text-delta" && "textDelta" in event) {
+      fullText += event.textDelta;
+      filter.feed(event.textDelta);
+    } else {
+      outerQueue.push(event);
+    }
+    originalPush(event);
+  };
+  const originalDone = innerQueue.done;
+  innerQueue.done = () => {
+    filter.flush();
+    outerQueue.done();
+    originalDone();
+  };
+  const originalError = innerQueue.error;
+  innerQueue.error = (e) => {
+    filter.flush();
+    outerQueue.error(e);
+    originalError(e);
+  };
+  const pipelinePromise = generateText(prompt, {
+    max_new_tokens: input.maxTokens ?? 1024,
+    temperature: input.temperature ?? undefined,
+    return_full_text: false,
+    streamer,
+    stopping_criteria: [stopping_criteria],
+    ...past_key_values ? { past_key_values } : {}
+  }).then(() => innerQueue.done(), (err) => innerQueue.error(err));
+  yield* outerQueue.iterable;
+  await pipelinePromise;
+  const parseableFullText = responsePrefix ? `${responsePrefix}${fullText}` : fullText;
+  const { text: cleanedText, toolCalls } = adaptParserResult(parseToolCalls(parseableFullText, { parser: modelFamily }));
+  const validToolCalls = filterValidToolCalls(normalizeParsedToolCalls(input, toolCalls), input.tools);
+  if (validToolCalls.length > 0) {
+    yield { type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] };
+  }
+  yield {
+    type: "finish",
+    data: { text: cleanedText, toolCalls: validToolCalls }
+  };
+};
+
+// src/ai-provider/common/HFT_Chat.ts
+async function generateTurn(input, model, sessionId, onProgress, signal, onDelta) {
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const hfTokenizer = generateText.tokenizer;
+  const hfModel = generateText.model;
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const messages = buildHFTMessages(input.messages, input.systemPrompt, input.prompt, undefined);
+  const prompt = hfTokenizer.apply_chat_template(messages, {
+    tokenize: false,
+    add_generation_prompt: true
+  });
+  const inputs = hfTokenizer(prompt);
+  const promptLen = inputs.input_ids.dims[1];
+  const modelPath = model.provider_config.model_path;
+  let session = sessionId ? getHftSession(sessionId) : undefined;
+  let past_key_values = undefined;
+  if (session?.mode === "prefix-rewind" && session.modelPath === modelPath) {
+    const { DynamicCache } = await loadTransformersSDK();
+    past_key_values = new DynamicCache(session.baseEntries);
+  }
+  let accumulated = "";
+  let streamer;
+  if (onDelta) {
+    const queue = createStreamEventQueue();
+    streamer = createStreamingTextStreamer(hfTokenizer, queue, TextStreamer);
+    queue.push = (event) => {
+      if (event.type === "text-delta" && "textDelta" in event) {
+        accumulated += event.textDelta;
+        onDelta(event.textDelta);
+      }
+    };
+  } else {
+    streamer = createTextStreamer(hfTokenizer, onProgress, TextStreamer);
+  }
+  const output = await hfModel.generate({
+    ...inputs,
+    max_new_tokens: input.maxTokens ?? 1024,
+    temperature: input.temperature ?? undefined,
+    streamer,
+    stopping_criteria: [stopping_criteria],
+    ...past_key_values ? { past_key_values } : {}
+  });
+  if (!onDelta) {
+    const seqLen = output.dims[1];
+    const newTokens = output.slice(0, [promptLen, seqLen], null);
+    accumulated = hfTokenizer.decode(newTokens, { skip_special_tokens: true });
+  }
+  if (sessionId) {
+    let outputCache;
+    if (past_key_values) {
+      outputCache = past_key_values;
+    } else if (output.past_key_values) {
+      outputCache = output.past_key_values;
+    }
+    if (outputCache) {
+      const baseEntries = {};
+      for (const key of Object.keys(outputCache)) {
+        baseEntries[key] = outputCache[key];
+      }
+      const newSession = {
+        mode: "prefix-rewind",
+        baseEntries,
+        baseSeqLength: outputCache.get_seq_length ? outputCache.get_seq_length() : 0,
+        modelPath
+      };
+      setHftSession(sessionId, newSession);
+    }
+  }
+  return accumulated;
+}
+var HFT_Chat = async (input, model, update_progress, signal, _outputSchema, sessionId) => {
+  update_progress(0, "HFT chat turn");
+  const text = await generateTurn(input, model, sessionId, update_progress, signal, undefined);
+  update_progress(100, "Turn complete");
+  return { text };
+};
+var HFT_Chat_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
+  const noopProgress = () => {};
+  const queue = [];
+  let done = false;
+  let resolver;
+  const task = (async () => {
+    try {
+      await generateTurn(input, model, sessionId, noopProgress, signal, (piece) => {
+        queue.push(piece);
+        resolver?.();
+      });
+    } finally {
+      done = true;
+      resolver?.();
+    }
+  })();
+  while (!done || queue.length > 0) {
+    if (queue.length === 0 && !done) {
+      await new Promise((res) => resolver = res);
+      resolver = undefined;
+    }
+    while (queue.length > 0) {
+      yield { type: "text-delta", port: "text", textDelta: queue.shift() };
+    }
+  }
+  await task;
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFT_CountTokens.ts
+init_HFT_Pipeline();
+var HFT_CountTokens = async (input, model, onProgress, _signal) => {
+  const { AutoTokenizer } = await loadTransformersSDK();
+  const tokenizer = await AutoTokenizer.from_pretrained(model.provider_config.model_path, {
+    progress_callback: (progress) => onProgress(progress?.progress ?? 0)
+  });
+  const tokenIds = tokenizer.encode(input.text);
+  return { count: tokenIds.length };
+};
+var HFT_CountTokens_Preview = async (input, model) => {
+  return HFT_CountTokens(input, model, () => {}, new AbortController().signal);
+};
+
+// src/ai-provider/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/ai-provider/common/HFT_ImageClassification.ts
+init_HFT_Pipeline();
+import { imageValueToBlob as imageValueToBlob2 } from "@workglow/ai-provider/common";
+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 imageArg2 = await imageValueToBlob2(input.image);
+    const result2 = await zeroShotClassifier(imageArg2, input.categories, {});
+    const results2 = Array.isArray(result2) ? result2 : [result2];
+    return {
+      categories: results2.map((r) => ({
+        label: r.label,
+        score: r.score
+      }))
+    };
+  }
+  const classifier = await getPipeline(model, onProgress, {}, signal);
+  const imageArg = await imageValueToBlob2(input.image);
+  const result = await classifier(imageArg, {
+    top_k: input.maxCategories
+  });
+  const results = Array.isArray(result) ? result : [result];
+  return {
+    categories: results.map((r) => ({
+      label: r.label,
+      score: r.score
+    }))
+  };
+};
+
+// src/ai-provider/common/HFT_ImageEmbedding.ts
+init_HFT_Pipeline();
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+import { imageValueToBlob as imageValueToBlob3 } from "@workglow/ai-provider/common";
+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
+  });
+  if (Array.isArray(input.image)) {
+    const vectors = [];
+    for (const image of input.image) {
+      const imageArg2 = await imageValueToBlob3(image);
+      const result2 = await embedder(imageArg2);
+      vectors.push(result2.data);
+    }
+    logger.timeEnd(timerLabel, { count: vectors.length });
+    return { vector: vectors };
+  }
+  const imageArg = await imageValueToBlob3(input.image);
+  const result = await embedder(imageArg);
+  logger.timeEnd(timerLabel, { dimensions: result?.data?.length });
+  return {
+    vector: result.data
+  };
+};
+
+// src/ai-provider/common/HFT_ImageSegmentation.ts
+init_HFT_Pipeline();
+import { imageValueToBlob as imageValueToBlob4 } from "@workglow/ai-provider/common";
+var HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
+  const segmenter = await getPipeline(model, onProgress, {}, signal);
+  const imageArg = await imageValueToBlob4(input.image);
+  const result = await segmenter(imageArg, {
+    threshold: input.threshold,
+    mask_threshold: input.maskThreshold
+  });
+  const masks = Array.isArray(result) ? result : [result];
+  const processedMasks = await Promise.all(masks.map(async (mask) => ({
+    label: mask.label || "",
+    score: mask.score || 0,
+    mask: {}
+  })));
+  return {
+    masks: processedMasks
+  };
+};
+
+// src/ai-provider/common/HFT_ImageToText.ts
+init_HFT_Pipeline();
+import { imageValueToBlob as imageValueToBlob5 } from "@workglow/ai-provider/common";
+var HFT_ImageToText = async (input, model, onProgress, signal) => {
+  const captioner = await getPipeline(model, onProgress, {}, signal);
+  const imageArg = await imageValueToBlob5(input.image);
+  const result = await captioner(imageArg, {
+    max_new_tokens: input.maxTokens
+  });
+  const text = Array.isArray(result[0]) ? result[0][0]?.generated_text : result[0]?.generated_text;
+  return {
+    text: text || ""
+  };
+};
+
+// src/ai-provider/common/HFT_ModelInfo.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+init_HFT_Pipeline();
+var HFT_ModelInfo = async (input, model) => {
+  if (input.detail === "dimensions") {
+    if (!model)
+      throw new Error("Model config is required for ModelInfoTask.");
+    const pc = model.provider_config;
+    let native_dimensions = typeof pc.native_dimensions === "number" ? pc.native_dimensions : undefined;
+    const mrl = typeof pc.mrl === "boolean" ? pc.mrl : false;
+    if (native_dimensions === undefined && typeof pc.model_path === "string") {
+      try {
+        const response = await fetch(`https://huggingface.co/${pc.model_path}/resolve/${pc.revision ?? "main"}/config.json`);
+        if (response.ok) {
+          const config = await response.json();
+          if (typeof config.hidden_size === "number") {
+            native_dimensions = config.hidden_size;
+          }
+        }
+      } catch {}
+    }
+    return {
+      model: input.model,
+      is_local: true,
+      is_remote: false,
+      supports_browser: true,
+      supports_node: true,
+      is_cached: false,
+      is_loaded: false,
+      file_sizes: null,
+      ...native_dimensions !== undefined ? { native_dimensions } : {},
+      ...mrl ? { mrl } : {}
+    };
+  }
+  const logger = getLogger4();
+  const { ModelRegistry } = await loadTransformersSDK();
+  const timerLabel = `hft:ModelInfo:${model?.provider_config.model_path}`;
+  logger.time(timerLabel, { model: model?.provider_config.model_path });
+  const detail = input.detail;
+  const is_loaded = hasCachedPipeline(getPipelineCacheKey(model));
+  const { pipeline: pipelineType, model_path, dtype, device } = model.provider_config;
+  const cacheOptions = {
+    ...dtype ? { dtype } : {},
+    ...device ? { device } : {}
+  };
+  const cacheStatus = await ModelRegistry.is_pipeline_cached_files(pipelineType, model_path, cacheOptions);
+  logger.debug("is_pipeline_cached", {
+    input: [pipelineType, model_path, cacheOptions],
+    result: cacheStatus
+  });
+  const is_cached = is_loaded || cacheStatus.allCached;
+  let file_sizes = null;
+  if (detail === "files" && cacheStatus.files.length > 0) {
+    const sizes = {};
+    for (const { file } of cacheStatus.files) {
+      sizes[file] = 0;
+    }
+    file_sizes = sizes;
+  } else if (detail === "files_with_metadata" && cacheStatus.files.length > 0) {
+    const sizes = {};
+    await Promise.all(cacheStatus.files.map(async ({ file }) => {
+      const metadata = await ModelRegistry.get_file_metadata(model_path, file);
+      if (metadata.exists && metadata.size !== undefined) {
+        sizes[file] = metadata.size;
+      }
+    }));
+    if (Object.keys(sizes).length > 0) {
+      file_sizes = sizes;
+    }
+  }
+  let quantizations;
+  if (cacheStatus.files.length > 0) {
+    const filePaths = cacheStatus.files.map((f) => f.file);
+    const quantizations_parsed = parseOnnxQuantizations({ filePaths });
+    if (quantizations_parsed.length > 0) {
+      quantizations = quantizations_parsed;
+    }
+  }
+  logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
+  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/ai-provider/common/HFT_ObjectDetection.ts
+init_HFT_Pipeline();
+import { imageValueToBlob as imageValueToBlob6 } from "@workglow/ai-provider/common";
+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 imageArg2 = await imageValueToBlob6(input.image);
+    const result = await zeroShotDetector(imageArg2, Array.from(input.labels), {
+      threshold: input.threshold
+    });
+    return {
+      detections: result.map((d) => ({
+        label: d.label,
+        score: d.score,
+        box: d.box
+      }))
+    };
+  }
+  const detector = await getPipeline(model, onProgress, {}, signal);
+  const imageArg = await imageValueToBlob6(input.image);
+  const detections = await detector(imageArg, {
+    threshold: input.threshold
+  });
+  return {
+    detections: detections.map((d) => ({
+      label: d.label,
+      score: d.score,
+      box: d.box
+    }))
+  };
+};
+
+// src/ai-provider/common/HFT_StructuredGeneration.ts
+init_HFT_Pipeline();
+import { parsePartialJson } from "@workglow/util/worker";
+
+// src/ai-provider/common/HFT_TextOutput.ts
+function extractGeneratedText(generatedText) {
+  if (generatedText == null)
+    return "";
+  if (typeof generatedText === "string")
+    return generatedText;
+  const lastMessage = generatedText[generatedText.length - 1];
+  if (!lastMessage)
+    return "";
+  const content = lastMessage.content;
+  if (typeof content === "string")
+    return content;
+  for (const part of content) {
+    if (part.type === "text" && "text" in part) {
+      return part.text;
+    }
+  }
+  return "";
+}
+
+// src/ai-provider/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 stripThinkingAndSpecialTokens(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/<\|[a-z_]+\|>/g, "").trim();
+}
+function extractJsonFromText(text) {
+  const cleaned = stripThinkingAndSpecialTokens(text);
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (match) {
+      try {
+        return JSON.parse(match[0]);
+      } catch {
+        return parsePartialJson(match[0]) ?? {};
+      }
+    }
+    return {};
+  }
+}
+var HFT_StructuredGeneration = async (input, model, onProgress, signal) => {
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const prompt = buildStructuredGenerationPrompt(input);
+  const messages = [{ role: "user", content: prompt }];
+  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
+    tokenize: false,
+    add_generation_prompt: true
+  });
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  let results = await generateText(formattedPrompt, {
+    max_new_tokens: input.maxTokens ?? 1024,
+    temperature: input.temperature ?? undefined,
+    return_full_text: false,
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  if (!Array.isArray(results)) {
+    results = [results];
+  }
+  const responseText = extractGeneratedText(results[0]?.generated_text).trim();
+  const object = extractJsonFromText(responseText);
+  return { object };
+};
+var HFT_StructuredGeneration_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const prompt = buildStructuredGenerationPrompt(input);
+  const messages = [{ role: "user", content: prompt }];
+  const formattedPrompt = generateText.tokenizer.apply_chat_template(messages, {
+    tokenize: false,
+    add_generation_prompt: true
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  let fullText = "";
+  let cleanedText = "";
+  let inThinkBlock = false;
+  let jsonStart = -1;
+  const originalPush = queue.push;
+  queue.push = (event) => {
+    if (event.type === "text-delta" && "textDelta" in event) {
+      const delta = event.textDelta;
+      fullText += delta;
+      let remaining = delta;
+      while (remaining.length > 0) {
+        if (inThinkBlock) {
+          const closeIdx = remaining.indexOf("</think>");
+          if (closeIdx !== -1) {
+            inThinkBlock = false;
+            remaining = remaining.slice(closeIdx + "</think>".length);
+          } else {
+            remaining = "";
+          }
+        } else {
+          const openIdx = remaining.indexOf("<think>");
+          if (openIdx !== -1) {
+            cleanedText += remaining.slice(0, openIdx).replace(/<\|[a-z_]+\|>/g, "");
+            inThinkBlock = true;
+            remaining = remaining.slice(openIdx + "<think>".length);
+          } else {
+            cleanedText += remaining.replace(/<\|[a-z_]+\|>/g, "");
+            remaining = "";
+          }
+        }
+      }
+      if (jsonStart === -1) {
+        jsonStart = cleanedText.indexOf("{");
+      }
+      if (jsonStart !== -1) {
+        const partial = parsePartialJson(cleanedText.slice(jsonStart));
+        if (partial !== undefined) {
+          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,
+    stopping_criteria: [stopping_criteria]
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  const object = extractJsonFromText(fullText);
+  yield { type: "finish", data: { object } };
+};
+
+// src/ai-provider/common/HFT_TextClassification.ts
+init_HFT_Pipeline();
+var HFT_TextClassification = async (input, model, onProgress, signal) => {
+  if (model?.provider_config?.pipeline === "zero-shot-classification") {
+    if (!input.candidateLabels || !Array.isArray(input.candidateLabels) || input.candidateLabels.length === 0) {
+      throw new Error("Zero-shot text classification requires candidate labels");
+    }
+    const zeroShotClassifier = await getPipeline(model, onProgress, {}, signal);
+    const result2 = await zeroShotClassifier(input.text, input.candidateLabels, {});
+    return {
+      categories: result2.labels.map((label, idx) => ({
+        label,
+        score: result2.scores[idx]
+      }))
+    };
+  }
+  const TextClassification = await getPipeline(model, onProgress, {}, signal);
+  const result = await TextClassification(input.text, {
+    top_k: input.maxCategories || undefined
+  });
+  return {
+    categories: result.map((category) => ({
+      label: category.label,
+      score: category.score
+    }))
+  };
+};
+
+// src/ai-provider/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/ai-provider/common/HFT_TextFillMask.ts
+init_HFT_Pipeline();
+var HFT_TextFillMask = async (input, model, onProgress, signal) => {
+  const unmasker = await getPipeline(model, onProgress, {}, signal);
+  const predictions = await unmasker(input.text);
+  return {
+    predictions: predictions.map((prediction) => ({
+      entity: prediction.token_str,
+      score: prediction.score,
+      sequence: prediction.sequence
+    }))
+  };
+};
+
+// src/ai-provider/common/HFT_TextGeneration.ts
+init_HFT_Pipeline();
+import { getLogger as getLogger6 } from "@workglow/util/worker";
+var HFT_TextGeneration = async (input, model, onProgress, signal, _outputSchema, sessionId) => {
+  const logger = getLogger6();
+  const timerLabel = `hft:TextGeneration:${model?.provider_config.model_path}`;
+  logger.time(timerLabel, { model: model?.provider_config.model_path });
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  logger.debug("HFT TextGeneration: pipeline ready, generating text", {
+    model: model?.provider_config.model_path,
+    promptLength: input.prompt?.length
+  });
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const modelPath = model.provider_config.model_path;
+  let session = sessionId ? getHftSession(sessionId) : undefined;
+  let past_key_values = undefined;
+  if (sessionId && !session) {
+    const sdk = await loadTransformersSDK();
+    const cache = new sdk.DynamicCache;
+    const newSession = {
+      mode: "progressive",
+      cache,
+      modelPath
+    };
+    setHftSession(sessionId, newSession);
+    session = newSession;
+  }
+  if (session?.mode === "progressive") {
+    past_key_values = session.cache;
+  }
+  const messages = [{ role: "user", content: input.prompt }];
+  let results = await generateText(messages, {
+    streamer,
+    do_sample: false,
+    max_new_tokens: input.maxTokens ?? 4 * 1024,
+    stopping_criteria: [stopping_criteria],
+    ...past_key_values ? { past_key_values } : {}
+  });
+  if (!Array.isArray(results)) {
+    results = [results];
+  }
+  const text = extractGeneratedText(results[0]?.generated_text);
+  logger.timeEnd(timerLabel, { outputLength: text?.length });
+  return {
+    text
+  };
+};
+var HFT_TextGeneration_Stream = async function* (input, model, signal, _outputSchema, sessionId) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const modelPath = model.provider_config.model_path;
+  let session = sessionId ? getHftSession(sessionId) : undefined;
+  let past_key_values = undefined;
+  if (sessionId && !session) {
+    const sdk = await loadTransformersSDK();
+    const cache = new sdk.DynamicCache;
+    const newSession = {
+      mode: "progressive",
+      cache,
+      modelPath
+    };
+    setHftSession(sessionId, newSession);
+    session = newSession;
+  }
+  if (session?.mode === "progressive") {
+    past_key_values = session.cache;
+  }
+  const messages = [{ role: "user", content: input.prompt }];
+  const pipelinePromise = generateText(messages, {
+    streamer,
+    do_sample: false,
+    max_new_tokens: input.maxTokens ?? 4 * 1024,
+    stopping_criteria: [stopping_criteria],
+    ...past_key_values ? { past_key_values } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFT_TextLanguageDetection.ts
+init_HFT_Pipeline();
+var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
+  const TextClassification = await getPipeline(model, onProgress, {}, signal);
+  const result = await TextClassification(input.text, {
+    top_k: input.maxLanguages || undefined
+  });
+  return {
+    languages: result.map((category) => ({
+      language: category.label,
+      score: category.score
+    }))
+  };
+};
+
+// src/ai-provider/common/HFT_TextNamedEntityRecognition.ts
+init_HFT_Pipeline();
+var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
+  const textNamedEntityRecognition = await getPipeline(model, onProgress, {}, signal);
+  const results = await textNamedEntityRecognition(input.text, {
+    ignore_labels: input.blockList
+  });
+  return {
+    entities: results.map((entity) => ({
+      entity: entity.entity,
+      score: entity.score,
+      word: entity.word
+    }))
+  };
+};
+
+// src/ai-provider/common/HFT_TextQuestionAnswer.ts
+init_HFT_Pipeline();
+var HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
+  const generateAnswer = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const result = await generateAnswer(input.question, input.context, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  const answerText = result?.answer || "";
+  return { text: answerText };
+};
+var HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateAnswer = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  let pipelineResult;
+  const pipelinePromise = generateAnswer(input.question, input.context, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  }).then((result) => {
+    pipelineResult = result;
+    queue.done();
+  }, (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  let answerText = "";
+  if (pipelineResult !== undefined) {
+    if (Array.isArray(pipelineResult)) {
+      answerText = pipelineResult[0]?.answer ?? "";
+    } else {
+      answerText = pipelineResult?.answer ?? "";
+    }
+  }
+  yield { type: "finish", data: { text: answerText } };
+};
+
+// src/ai-provider/common/HFT_TextRewriter.ts
+init_HFT_Pipeline();
+var HFT_TextRewriter = async (input, model, onProgress, signal) => {
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const promptedText = (input.prompt ? input.prompt + `
+` : "") + input.text;
+  let results = await generateText(promptedText, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  if (!Array.isArray(results)) {
+    results = [results];
+  }
+  const text = extractGeneratedText(results[0]?.generated_text);
+  if (text === promptedText) {
+    throw new Error("Rewriter failed to generate new text");
+  }
+  return {
+    text
+  };
+};
+var HFT_TextRewriter_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const promptedText = (input.prompt ? input.prompt + `
+` : "") + input.text;
+  const pipelinePromise = generateText(promptedText, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFT_TextSummary.ts
+init_HFT_Pipeline();
+var HFT_TextSummary = async (input, model, onProgress, signal) => {
+  const generateSummary = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const streamer = createTextStreamer(generateSummary.tokenizer, onProgress, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const result = await generateSummary(input.text, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  let summaryText = "";
+  if (Array.isArray(result)) {
+    summaryText = result[0]?.summary_text || "";
+  } else {
+    summaryText = result?.summary_text || "";
+  }
+  return {
+    text: summaryText
+  };
+};
+var HFT_TextSummary_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateSummary = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const pipelinePromise = generateSummary(input.text, {
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/common/HFT_TextTranslation.ts
+init_HFT_Pipeline();
+var HFT_TextTranslation = async (input, model, onProgress, signal) => {
+  const translate = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const streamer = createTextStreamer(translate.tokenizer, onProgress, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const result = await translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  });
+  const translatedText = Array.isArray(result) ? result[0]?.translation_text || "" : result?.translation_text || "";
+  return {
+    text: translatedText,
+    target_lang: input.target_lang
+  };
+};
+var HFT_TextTranslation_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const translate = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer, InterruptableStoppingCriteria } = await loadTransformersSDK();
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(translate.tokenizer, queue, TextStreamer);
+  const stopping_criteria = new InterruptableStoppingCriteria;
+  if (signal) {
+    signal.addEventListener("abort", () => stopping_criteria.interrupt(), { once: true });
+  }
+  const pipelinePromise = translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    streamer,
+    stopping_criteria: [stopping_criteria]
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: { target_lang: input.target_lang } };
+};
+
+// src/ai-provider/common/HFT_Unload.ts
+init_HFT_Pipeline();
+function hasBrowserCacheStorage() {
+  return typeof globalThis !== "undefined" && "caches" in globalThis && typeof globalThis.caches?.open === "function";
+}
+async function deleteModelCacheFromBrowser(model_path) {
+  const cachesApi = globalThis.caches;
+  const cache = await cachesApi.open(HTF_CACHE_NAME);
+  const keys = await cache.keys();
+  const prefix = `/${model_path}/`;
+  const requestsToDelete = [];
+  for (const request of keys) {
+    const url = new URL(request.url);
+    if (url.pathname.startsWith(prefix)) {
+      requestsToDelete.push(request);
+    }
+  }
+  for (const request of requestsToDelete) {
+    try {
+      const deleted = await cache.delete(request);
+      if (!deleted) {
+        const deletedByUrl = await cache.delete(request.url);
+        if (!deletedByUrl) {}
+      }
+    } catch (error) {
+      console.error(`Failed to delete cache entry: ${request.url}`, error);
+    }
+  }
+}
+async function deleteModelCacheFromFilesystem(model) {
+  const { ModelRegistry } = await loadTransformersSDK();
+  const { pipeline: pipelineType, model_path, dtype } = model.provider_config;
+  await ModelRegistry.clear_pipeline_cache(pipelineType, model_path, {
+    ...dtype ? { dtype } : {}
+  });
+}
+var HFT_Unload = async (input, model, onProgress, _signal) => {
+  const cacheKey = getPipelineCacheKey(model);
+  if (removeCachedPipeline(cacheKey)) {
+    onProgress(50, "Pipeline removed from memory");
+  }
+  const model_path = model.provider_config.model_path;
+  disposeHftSessionsForModel(model_path);
+  if (hasBrowserCacheStorage()) {
+    await deleteModelCacheFromBrowser(model_path);
+  } else {
+    await deleteModelCacheFromFilesystem(model);
+  }
+  onProgress(100, "Model cache deleted");
+  return {
+    model: input.model
+  };
+};
+
+// src/ai-provider/common/HFT_JobRunFns.ts
+var HFT_TASKS = {
+  AiChatTask: HFT_Chat,
+  DownloadModelTask: HFT_Download,
+  UnloadModelTask: HFT_Unload,
+  ModelInfoTask: HFT_ModelInfo,
+  CountTokensTask: HFT_CountTokens,
+  TextEmbeddingTask: HFT_TextEmbedding,
+  TextGenerationTask: HFT_TextGeneration,
+  TextQuestionAnswerTask: HFT_TextQuestionAnswer,
+  TextLanguageDetectionTask: HFT_TextLanguageDetection,
+  TextClassificationTask: HFT_TextClassification,
+  TextFillMaskTask: HFT_TextFillMask,
+  TextNamedEntityRecognitionTask: HFT_TextNamedEntityRecognition,
+  TextRewriterTask: HFT_TextRewriter,
+  TextSummaryTask: HFT_TextSummary,
+  TextTranslationTask: HFT_TextTranslation,
+  ImageSegmentationTask: HFT_ImageSegmentation,
+  ImageToTextTask: HFT_ImageToText,
+  BackgroundRemovalTask: HFT_BackgroundRemoval,
+  ImageEmbeddingTask: HFT_ImageEmbedding,
+  ImageClassificationTask: HFT_ImageClassification,
+  ObjectDetectionTask: HFT_ObjectDetection,
+  ToolCallingTask: HFT_ToolCalling,
+  StructuredGenerationTask: HFT_StructuredGeneration,
+  ModelSearchTask: HFT_ModelSearch
+};
+var HFT_STREAM_TASKS = {
+  AiChatTask: HFT_Chat_Stream,
+  TextGenerationTask: HFT_TextGeneration_Stream,
+  TextRewriterTask: HFT_TextRewriter_Stream,
+  TextSummaryTask: HFT_TextSummary_Stream,
+  TextQuestionAnswerTask: HFT_TextQuestionAnswer_Stream,
+  TextTranslationTask: HFT_TextTranslation_Stream,
+  ToolCallingTask: HFT_ToolCalling_Stream,
+  StructuredGenerationTask: HFT_StructuredGeneration_Stream
+};
+var HFT_PREVIEW_TASKS = {
+  CountTokensTask: HFT_CountTokens_Preview
+};
+
+// src/ai-provider/registerHuggingFaceTransformersInline.ts
+init_HFT_Pipeline();
+
+// src/ai-provider/HuggingFaceTransformersQueuedProvider.ts
+import { QueuedAiProvider } from "@workglow/ai";
+init_HFT_Pipeline();
+var GPU_DEVICES = new Set(["webgpu", "gpu", "metal"]);
+var HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION = 4;
+function hftIsAutomatedTestEnvironment() {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const e = process.env;
+  return e.VITEST === "true" || e.NODE_ENV === "test" || e.BUN_TEST === "1" || e.JEST_WORKER_ID !== undefined;
+}
+function hftDefaultCpuQueueConcurrency() {
+  return hftIsAutomatedTestEnvironment() ? 1 : HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION;
+}
+function resolveHftCpuQueueConcurrency(concurrency, defaultCpu) {
+  if (concurrency === undefined) {
+    return defaultCpu();
+  }
+  if (typeof concurrency === "number") {
+    return defaultCpu();
+  }
+  return concurrency.cpu ?? defaultCpu();
+}
+
+class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
+  name = HF_TRANSFORMERS_ONNX;
+  displayName = "Hugging Face Transformers (ONNX)";
+  isLocal = true;
+  supportsBrowser = true;
+  cpuStrategy;
+  taskTypes = [
+    "AiChatTask",
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "ModelInfoTask",
+    "CountTokensTask",
+    "TextEmbeddingTask",
+    "TextGenerationTask",
+    "TextQuestionAnswerTask",
+    "TextLanguageDetectionTask",
+    "TextClassificationTask",
+    "TextFillMaskTask",
+    "TextNamedEntityRecognitionTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "TextTranslationTask",
+    "ImageSegmentationTask",
+    "ImageToTextTask",
+    "BackgroundRemovalTask",
+    "ImageEmbeddingTask",
+    "ImageClassificationTask",
+    "ObjectDetectionTask",
+    "ToolCallingTask",
+    "StructuredGenerationTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(sessionId) {
+    deleteHftSession(sessionId);
+  }
+  async afterRegister(options) {
+    await super.afterRegister(options);
+    this.cpuStrategy = this.createQueuedStrategy(HF_TRANSFORMERS_ONNX_CPU, resolveHftCpuQueueConcurrency(options.queue?.concurrency, hftDefaultCpuQueueConcurrency), options);
+  }
+  getStrategyForModel(model) {
+    const device = model.provider_config?.device;
+    if (device && GPU_DEVICES.has(device)) {
+      return this.queuedStrategy;
+    }
+    return this.cpuStrategy;
+  }
+}
+
+// src/ai-provider/registerHuggingFaceTransformersInline.ts
+async function registerHuggingFaceTransformersInline(options) {
+  const { env } = await loadTransformersSDK();
+  env.backends.onnx.wasm.proxy = true;
+  const provider = new HuggingFaceTransformersQueuedProvider(HFT_TASKS, HFT_STREAM_TASKS, HFT_PREVIEW_TASKS);
+  const baseDispose = provider.dispose.bind(provider);
+  provider.dispose = async () => {
+    await clearHftInlinePipelineCache();
+    await baseDispose();
+  };
+  await registerProviderInline(provider, "HuggingFaceTransformers", options);
+}
+
+// src/ai-provider/registerHuggingFaceTransformersWorker.ts
+import { registerProviderWorker } from "@workglow/ai-provider/common";
+
+// src/ai-provider/HuggingFaceTransformersProvider.ts
+import { AiProvider } from "@workglow/ai/worker";
+init_HFT_Pipeline();
+
+class HuggingFaceTransformersProvider extends AiProvider {
+  name = HF_TRANSFORMERS_ONNX;
+  displayName = "Hugging Face Transformers (ONNX)";
+  isLocal = true;
+  supportsBrowser = true;
+  taskTypes = [
+    "AiChatTask",
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "ModelInfoTask",
+    "CountTokensTask",
+    "TextEmbeddingTask",
+    "TextGenerationTask",
+    "TextQuestionAnswerTask",
+    "TextLanguageDetectionTask",
+    "TextClassificationTask",
+    "TextFillMaskTask",
+    "TextNamedEntityRecognitionTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "TextTranslationTask",
+    "ImageSegmentationTask",
+    "ImageToTextTask",
+    "BackgroundRemovalTask",
+    "ImageEmbeddingTask",
+    "ImageClassificationTask",
+    "ObjectDetectionTask",
+    "ToolCallingTask",
+    "StructuredGenerationTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(sessionId) {
+    deleteHftSession(sessionId);
+  }
+}
+
+// src/ai-provider/registerHuggingFaceTransformersWorker.ts
+init_HFT_Pipeline();
+async function registerHuggingFaceTransformersWorker() {
+  const sdk = await loadTransformersSDK();
+  globalThis.__HFT__ = sdk;
+  const { env } = sdk;
+  env.backends.onnx.wasm.proxy = true;
+  await registerProviderWorker((ws) => new HuggingFaceTransformersProvider(HFT_TASKS, HFT_STREAM_TASKS, HFT_PREVIEW_TASKS).registerOnWorkerServer(ws), "HuggingFaceTransformers");
+}
+export {
+  setHftSession,
+  setHftCacheDir,
+  removeCachedPipeline,
+  registerHuggingFaceTransformersWorker,
+  registerHuggingFaceTransformersInline,
+  parseOnnxQuantizations,
+  loadTransformersSDK,
+  hasCachedPipeline,
+  getPipelineCacheKey,
+  getPipeline,
+  getHftSession,
+  disposeHftSessionsForModel,
+  deleteHftSession,
+  createToolCallMarkupFilter,
+  clearPipelineCache,
+  QuantizationDataType,
+  PipelineUseCase,
+  ONNX_QUANTIZATION_SUFFIX_MAPPING,
+  HfTransformersOnnxModelSchema,
+  HfTransformersOnnxModelRecordSchema,
+  HfTransformersOnnxModelConfigSchema,
+  HTF_CACHE_NAME,
+  HF_TRANSFORMERS_ONNX_GPU,
+  HF_TRANSFORMERS_ONNX_CPU,
+  HF_TRANSFORMERS_ONNX,
+  HFT_NULL_PROCESSOR_PREFIX
+};
+
+//# debugId=FDAFA958F0DFFF6D64756E2164756E21