@workglow/huggingface-transformers 0.2.28

package/dist/ai-provider.js

@@ -0,0 +1,879 @@
+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/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/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/registerHuggingFaceTransformers.ts
+import { registerProviderWithWorker } from "@workglow/ai-provider/common";
+async function registerHuggingFaceTransformers(options) {
+  await registerProviderWithWorker(new HuggingFaceTransformersQueuedProvider, "HuggingFaceTransformers", options);
+}
+
+// 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 };
+}
+export {
+  registerHuggingFaceTransformers,
+  parseOnnxQuantizations,
+  createToolCallMarkupFilter,
+  QuantizationDataType,
+  PipelineUseCase,
+  ONNX_QUANTIZATION_SUFFIX_MAPPING,
+  HuggingFaceTransformersQueuedProvider,
+  HuggingFaceTransformersProvider,
+  HfTransformersOnnxModelSchema,
+  HfTransformersOnnxModelRecordSchema,
+  HfTransformersOnnxModelConfigSchema,
+  HTF_CACHE_NAME,
+  HF_TRANSFORMERS_ONNX_GPU,
+  HF_TRANSFORMERS_ONNX_CPU,
+  HF_TRANSFORMERS_ONNX
+};
+
+//# debugId=158703D87AE0C17864756E2164756E21